Dart SDK: baixar versions anteriors

Released on: Unreleased
Language
Dart 3.13 adds primary constructors to the language. To use this feature, set your package's SDK constraint lower bound to 3.13 or greater (sdk: '^3.13.0').
Primary constructors
The primary constructors feature is a brevity feature. There are no new semantics, but it lets you express declarations in a less verbose way.
This feature lets you specify one constructor and a set of instance variables in the header of a declaration.
Currently, you write a declaration with a constructor and some fields as:
// Current syntax.
class Point {
int x;
int y;
Point(this.x, this.y);
}
Now you can write:
class Point(var int x, var int y);
If a primary constructor needs an initializer list, a body, or both, you can specify them inside the class using the this body syntax:
class Point(var int x, var int y) {
this : assert(x >= 0) {
print('Point created at $x, $y');
}
}
As part of this feature, you can also use the new and factory keywords to declare constructors in the class body without repeating the class name:
class Point {
int x, y;

// Equivalent to `Point(this.x, this.y)`:
new(this.x, this.y);

// Equivalent to `Point.origin()`:
new origin() : x = 0, y = 0;

// Equivalent to `factory Point.clone(Point other)`:
factory clone(Point other) => Point(other.x, other.y);
}
To learn more about the feature, check out the feature specification.
Other changes
- Breaking change: A minor change has been made to type promotion to avoid unsound behavior. See SDK issue #62889 for details.
Libraries
dart:async
- Added Future.pause as an alternative to Future.delayed with no callback.
dart:core
- Added List.unmodifiableOf with better typing than List.unmodifiable.
- Added Map.unmodifiableOf with better typing than Map.unmodifiable.
- Added two getters on int for efficient bit-counting: trailingZeroBitCount (ctz) and oneBitCount (popcount). On native platforms they operate on the full 64-bit two's-complement representation; on the web they operate on the least-significant 32 bits. For more details, see SDK issue #52673.
dart:io
- The cookie-date parser now uses the correct algorithm again. A change to the parsing made it only accept the formats that cookie dates should have, but the RFC specifies a very permissive algorithm for what should be accepted.
- Behavioral change: File access and modification timestamps (File.lastModified, FileStat, lastAccessed, lastModified, setLastAccessed, setLastModified) now preserve microsecond precision instead of truncating or rounding to millisecond accuracy. See SDK issue #42444.
- Breaking change: Added InterfaceAddress, a subtype of InternetAddress that exposes a prefixLength field and a broadcast getter for network interface addresses. NetworkInterface.addresses now returns List<InterfaceAddress> instead of List<InternetAddress>. Code that implements NetworkInterface and overrides addresses will need to update the return type. For more details, see SDK issue #63216.
- The InternetAddress.lookup function no longer accepts invalid IPv4 addresses that are traditionally accepted by inet_aton.
dart:isolate
- Added synchronous execution and event loop control APIs to Isolate: Isolate.runSync, Isolate.create, Isolate.shutdownSync, Isolate.pinToCurrentThread, Isolate.isPinnedToCurrentThread, Isolate.runEventLoopSync, Isolate.onEvent, and Isolate.handleEvent.
dart:js_interop
- JSFunction and JSExportedDartFunction are now generic. JSExportedDartFunction<T>.toDart now casts the original wrapped function to the type argument T. Calls to isA<JSExportedDartFunction<T>> now also check that the wrapped function is a T. Otherwise, this type argument is purely descriptive and intended for increased static type safety. Importantly, the runtime types of JSFunction and JSExportedDartFunction do not change. For more details, see SDK issue #54557.
- JSObject.getPrototypeOf is added.
Tools
Analyzer
- Added LSP support for Inline Values (textDocument/inlineValue), allowing IDEs and debuggers to render inline 

Released on: Unreleased
Language
Private named parameters
Dart now supports private named parameters. Before 3.12, it was an error to have a named parameter that starts with an underscore:
class Point {
final int _x, _y;
// Compile error in Dart 3.11.
Point({required this._x, required this._y});
}
This means that, before 3.12, initializing a private field from a named parameter required an explicit initializer list:
class Point {
final int _x, _y;
Point({required int x, required int y})
: _x = x,
_y = y;
}
All the initializer list is doing is removing the leading _. In Dart 3.12, the language does that for you. Now you can write:
class Point {
final int _x, _y; // Private fields.
Point({required this._x, required this._y});
}
This code behaves exactly like the previous example. The initialized fields are private, but the argument names written at the call site are public:
void main() {
print(Point(x: 1, y: 2));
}
Libraries
dart:core
- The Dart VM's RegExp implementation now supports modifier spans and duplicate named capture groups.
dart:js_interop
- Breaking change in extension name of isA: isA is moved from JSAnyUtilityExtension to NullableObjectUtilExtension to support type-checking any Object?. isA<JSObject>() also now handles JS objects with no prototypes correctly and isA<JSAny>() does a non-trivial check to make sure the value is a JS value. See #56905 for more details. As JSAnyUtilityExtension is on JSAny? and NullableObjectUtilExtension is on the supertype Object?, this change is only breaking if users referred to the extension name directly, either through applying the extension directly or through using show/hide directives.
- isA<JSExportedDartFunction>() now checks whether the function is actually a JS wrapper function that is returned from Function.toJS or Function.toJSCaptureThis.
- Added JSIterableProtocol, JSIterable, JSIteratorProtocol, JSIterator, and JSIteratorResult types to model JavaScript's iteration protocols. JSArray and JSString now implement JSIterable.
- Added extension types to provide Iterable.toJSIterable, JSIterable.toDartIterable, Iterator.toJSIterator, and JSIterator.toDartIterator.
Tools
Analyzer
- The new simple_directive_paths lint and its associated fix flag and simplify unnecessarily complex import and export paths, such as those containing redundant ./ or backtracking ../ segments.
Use dart fix --code=simple_directive_paths (with either --dry-run or --apply) to bulk fix existing lint violations.
- The prefer_initializing_formals lint rule highlights named parameters that could be private named parameters.
Use dart fix --code=prefer_initializing_formals (with either --dry-run or --apply) to bulk fix existing lint violations.
- Violations of the avoid_final_parameters lint can now be fixed with dart fix --code=avoid_final_parameters.
- The analyzer now warns when a function that contains a parameter annotated with @mustBeConst is torn off.
- The invalid_runtime_check_with_js_interop_types rule now checks for JS interop types used in a catch clause's on-type and instructs users to use isA for type checks instead.
- Analyzer plugins: Initial support for 'print debugging' via new sections in the "Plugins" Insights (Diagnostics) page. When a plugin is computing lint and warning diagnostics, print calls are now redirected to the analysis server, which presents the messages in the appropriate plugin's section on the Plugins page.
- Improved support for extension types in many existing lint rules.
- Improved support for null-aware elements in existing lint rules.
- The analysis server starts up faster with the help of improved analysis options file caching. The improvement depends on the number of analysis options files in the workspace, and the number of included analysis options files. The improvement is greater for systems with slower disk access.
- Various other improvements to analysis performance.
Pub
- dart pub cache repair now, by default, only repairs the packages referenced by the curr

Released on: Unreleased
Language
There are no language changes in this release.
Libraries
dart:io
- Added support for Unix domain sockets (AF_UNIX) on Windows. Support is restricted to the subset of features supported by the OS. Windows currently does not support the following features for AF_UNIX sockets: datagram sockets, ancillary data or abstract socket addresses. Unix domain sockets are represented in the file-system using reparse points which leads to some discrepancies in the behavior of dart:io APIs: for example File(socketPath).existsSync() will return true on POSIX operating systems, but false on Windows. Use FileSystemEntity.typeSync() instead to get portable behavior.
dart:js_interop
- Added a constructor to JSSymbol, as well as JSSymbol.key, JSSymbol.description, and static methods for all well-known ECMAScript symbols.
dart:js_util
- dart2wasm no longer supports dart:js_util. Any code that imports dart:js_util will no longer compile with dart2wasm. Consequently, code that depends on package:js will no longer compile with dart2wasm either. The name dart.library.js_util is no longer a key in dart2wasm compilation environments, including in conditional imports and exports. See #61550 for more details.
Tools
Analyzer
- The Insights pages (aka the "Analysis Server Diagnostics" pages) now show data regarding the "Message Scheduler."
- The "Fix all in workspace" command now supports a progress indicator.
- Analysis via analyzer plugins is now faster on subsequent runs, as the analysis server will now re-use an existing AOT snapshot of the plugins entrypoint. This saves a constant amount of time at the start of each IDE session and dart analyze run, on the order of 10 seconds.
- Various fixes are made for the call method on a Function object, like "go to definition," and completion.
- Various fixes are made for the error and stackTrace parameters of try/catch statements.
- Various fixes are made for syntax highlighting, navigation, code completion, hovers, quick fixes, assists, "rename" refactoring, and "go to imports."
- Various fixes for IDE features with regards to "Dot Shorthand" syntax.
- Improvements to LSP format-on-type, to not format in undesirable cases.
- Various performance improvements.
- Fixes to the 'Extract Widget' refactoring.
- (Thanks @FMorschel and @DanTup for many of the above enhancements!)
- A new lint rule is offered: simplify_variable_pattern, which encourages using the pattern shorthand for variables and property names of the same name.
- The avoid_null_checks_in_equality_operators lint rule is now deprecated.
- The prefer_final_parameters lint rule is now deprecated.
- The use_if_null_to_convert_nulls_to_bools lint rule is now deprecated.
Dart Development Compiler (dartdevc)
- The async timing of the Future returned by deferred_prefix.loadLibrary() is now consistent regardless if proper deferred imports are supported in the runtime environment or not. This makes the timing more consistent with dart2js where the loads are always an async operation.
Pub
- "Glob" support for pub workspaces.
Now to include all packages inside pkgs/ in the workspace, simply write:
workspace:
- pkgs/*
Supported if the Dart SDK constraint of the containing package is 3.11.0 or higher.
- New commmand dart pub cache gc for reclaiming disk space from your pub cache.
It works by removing packages from your pub cache that are not referenced by any of your current projects.
- New flag dart pub publish --dry-run --ignore-warnings
Given this flag, dart pub publish --dry-run will only exit non-zero if your project validation has errors.

Released on: 2025-11-12
Language
Dart 3.10 adds dot shorthands to the language. To use them, set your package's SDK constraint lower bound to 3.10 or greater (sdk: '^3.10.0').
Dart 3.10 also adjusts the inferred return type of a generator function (sync* or async*) to avoid introducing unneeded nullability.
Dot shorthands
Dot shorthands allow you to omit the type name when accessing a static member in a context where that type is expected.
These are some examples of ways you can use dot shorthands:
Color color = .blue;
switch (color) {
case .blue:
print('blue');
case .red:
print('red');
case .green:
print('green');
}
Column(
crossAxisAlignment: .start,
mainAxisSize: .min,
children: widgets,
)
To learn more about the feature, check out the feature specification.
Eliminate spurious Null from generator return type
The following local function f used to have return type Iterable<int?>. The question mark in this type is spurious because the returned iterable will never contain null (return; stops the iteration, it does not add null to the iterable). This feature makes the return type Iterable<int>.
void main() {
f() sync* {
yield 1;
return;
}
}
This change may cause some code elements to be flagged as unnecessary. For example, f().first?.isEven is flagged, and f().first.isEven is recommended instead.
Tools
Analyzer
- The analyzer includes a new plugin system. You can use this system to write your own analysis rules and IDE quick fixes.
- Analysis rules: Static analysis checks that report diagnostics (lints or warnings). You see these in your IDE and at the command line via dart analyze or flutter analyze.
- Quick fixes: Local refactorings that correct a reported lint or warning.
- Quick assists: Local refactorings available in the IDE that are not associated with a specific diagnostic.
See the documentation for writing an analyzer plugin, and the documentation for using analyzer plugins to learn more.
- Lint rules which are incompatible with each other and which are specified in included analysis options files are now reported.
- Offer to add required named field formal parameters in a constructor when a field is not initialized.
- Support the new @Deprecated annotations by reporting warnings when specific functionality of an element is deprecated.
- Offer to import a library for an appropriate extension member when method or property is accessed on a nullable value.
- Offer to remove the const keyword for a constructor call which includes a method invocation.
- Remove support for the deprecated @required annotation.
- Add two assists to bind constructor parameters to an existing or a non-existing field.
- Add a warning which is reported when an @experimental member is used outside of the package in which it is declared.
- Add a new lint rule, remove_deprecations_in_breaking_versions, is added to encourage developers to remove any deprecated members when the containing package has a "breaking version" number, like x.0.0 or 0.y.0.
- (Thanks @FMorschel for many of the above enhancements!)
Dart CLI and Dart VM
- The Dart CLI and Dart VM have been split into two separate executables.
The Dart CLI tool has been split out of the VM into it's own embedder which runs in AOT mode. The pure Dart VM executable is called dartvm and has no Dart CLI functionality in it.
The Dart CLI executable parses the CLI commands and invokes the rest of the AOT tools in the same process, for the 'run' and 'test' commands it execs a process which runs dartvm.
dart hello.dart execs the dartvm process and runs the hello.dart file.
The Dart CLI is not generated for ia32 as we are not shipping a Dart SDK for ia32 anymore (support to execute the dartvm for ia32 architecture is retained).
Libraries
dart:async
- Added Future.syncValue constructor for creating a future with a known value. Unlike Future.value, it does not allow an asynchronous Future<T> as the value of a new Future<T>.
dart:core
- Breaking Change #61392: The Uri.parseIPv4Address function no longer inc

Released on: 2025-08-13
Language
Dart 3.9 assumes null safety when computing type promotion, reachability, and definite assignment. This makes these features produce more accurate results for modern Dart programs. As a result of this change, more dead_code warnings may be produced. To take advantage of these improvements, set your package's SDK constraint lower bound to 3.9 or greater (sdk: '^3.9.0').
Tools
Analyzer
- The dart command-line tool commands that use the analysis server now run the AOT-compiled analysis server snapshot. These include dart analyze, dart fix, and dart language-server.
There is no functional difference when using the AOT-compiled analysis server snapshot. But various tests indicate that there is a significant speedup in the time to analyze a project.
In case of an incompatibility with the AOT-compiled snapshot, a --no-use-aot-snapshot flag may be passed to these commands. (Please file an issue with the appropriate project if you find that you need to use this flag! It will be removed in the future.) This flag directs the tool to revert to the old behavior, using the JIT-compiled analysis server snapshot. To direct the Dart Code plugin for VS Code to pass this flag, use the dart.analyzerAdditionalArgs setting. To direct the Dart IntelliJ plugin to pass this flag, use the dart.server.additional.arguments registry property, similar to these steps.
- Add the switch_on_type lint rule.
- Add the unnecessary_unawaited lint rule.
- Add an assist to convert a field formal parameter to a normal parameter.
Dart build
- Breaking change of feature in preview: dart build -f exe <target> is now dart build cli --target=<target>. See dart build cli --help for more info.
Dart Development Compiler (dartdevc)
- Outstanding async code now checks and cancels itself after a hot restart if it was started in a different generation of the application before the restart. This includes outstanding Futures created by calling JSPromise.toDart from thedart:js_interop and the underlying the dart:js_util helper promiseToFuture. Dart callbacks will not be run, but callbacks on the JavaScript side will still be executed.
- Fixed a soundness issue that allowed direct invocation of the 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.
A getter defined as:
class Container<T> {
T get value => _value;
...
}
Could trigger the issue with a direct invocation:
Container<dynamic>().value('Invocation with missing runtime checks!');
Dart native compiler
Added cross-compilation support for target architectures of arm (ARM32) and riscv64 (RV64GC) when the target OS is Linux.
Pub
- Git dependencies can now be version-solved based on git tags.
Use a tag_pattern in the descriptor and a version constraint, and all commits matching the pattern will be considered during resolution. For example:
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. For example:
name: my_app
environment:
sdk: ^3.9.0
flutter: 3.33.0
Results in dart pub get failing if invoked with a version of the Flutter SDK different from 3.33.0.
The upper bound of the flutter constraint is still ignored in packages used as dependencies. See https://github.com/flutter/flutter/issues/95472 for details.

Released on: 2025-05-28
This is a patch release that:
- Fixes an issue in DDC with late variables being incorrectly captured within async function bodies (issue #430800)

Released on: 2025-05-20
Language
Dart 3.8 adds null-aware elements to the language. To use them, set your package's SDK constraint lower bound to 3.8 or greater (sdk: '^3.8.0').
Null-Aware Elements
Null-aware elements make it easier to omit a value from a collection literal if it's null. The syntax works in list literals, set literals, and map literals. For map literals, both null-aware keys and values are supported. Here is an example a list literal written in both styles, without the null-aware elements language feature and with it:
String? lunch = isTuesday ? 'tacos!' : null;

var withoutNullAwareElements = [
if (lunch != null) lunch,
if (lunch.length != null) lunch.length!,
if (lunch.length case var length?) length,
];

var withNullAwareElements = [
?lunch,
?lunch.length,
?lunch.length,
];
Full details are in the feature specification.
Libraries
dart:core
- Added Iterable.withIterator constructor.
dart:io
- Added HttpClientBearerCredentials.
- Updated Stdout.supportsAnsiEscapes and Stdin.supportsAnsiEscapes to return true for TERM containing tmux values.
dart:html
- Breaking change: Native classes in dart:html, like HtmlElement, can no longer be extended. Long ago, to support custom elements, element classes exposed a .created constructor that adhered to the v0.5 spec of web components. On this release, those constructors have been removed and with that change, the classes can no longer be extended. In a future change, they may be marked as interface classes as well. This is a follow up from an earlier breaking change in 3.0.0 that removed the registerElement APIs. See #53264 for details.
dart:ffi
- Added Array.elements which exposes an Iterable over the Array's content.
Tools
Analyzer
- The analyzer now supports "doc imports," a new comment-based syntax which enables external elements to be referenced in documentation comments without actually importing them. See the documentation for details.
- Code completion is improved to offer more valid suggestions. In particular, the suggestions are improved when completing text in a comment reference on a documentation comment for an extension, a typedef, or a directive (an import, an export, or a library). Additionally, instance members can now be suggested in a documentation comment reference.
- Offer additional assist to wrap a Flutter widget with a FutureBuilder widget.
- Add a quick assist to wrap with ValueListenableBuilder.
- Add a quick fix to convert an (illegal) extension field declaration into a getter declaration.
- Add a quick fix to help code comply with a few lint rules that encourage omitting types: omit_local_variable_types, omit_obvious_local_variable_types, and omit_obvious_property_types.
- Add a quick fix to create an extension method to resolve an "undefined method invocation" error.
- Renaming a closure parameter is now possible.
- Renaming a field now adjusts implicit this references in order to avoid name collisions.
- Renaming a field formal parameter now properly renames known super-parameters in subclasses in other libraries.
- Renaming a method parameter now properly renames across the type hierarchy.
- The "encapsulate field" quick assist now works on final fields.
- The "inline method" refactoring now properly handles inner closures.
- The quick fix that adds names to a show clause or removes names from a hide clause can now add or remove multiple names simultaneously, in order to resolve as many "undefined" errors as possible.
- The "remove const" quick fix now operates on more types of code.
- The "add missing required argument" quick fix can now add multiple missing required arguments.
- Add a new warning that reports an import or export directive with multiple show or hide clauses, which are never necessary.
- Add a quick fix for this warning.
- Add LSP document links for lint rules in analysis options files.
- Add LSP document links for dependency packages in pubspec files.
- Fix various issues around patterns, like highlighting, navigation, and

Released on: 2025-01-30
- Fixes a bug where HttpServer responses were not correctly encoded if a "Content-Type" header was set (issue #59719).
- Fix dart format to parse code at language version 3.6 so that digit separators can be parsed correctly (issue #59815, dart_style issue #1630).
- Fixes an issue where the DevTools analytics did not distinguish between new and legacy inspector events (issue #59884).
- When running dart fix on a folder that contains a library with multiple files and more than one needs a fix, the fix will now be applied correctly only once to each file (issue #59572).

Language
Dart 3.6 adds digit separators to the language. To use them, set your package's SDK constraint lower bound to 3.6 or greater (sdk: '^3.6.0').
Digit separators
Digits in number literals (decimal integer literals, double literals, scientific notation literals, and hexadecimal literals) can now include underscores between digits, as "digit separators." The separators do not change the value of a literal, but can serve to make the number more readable.
100__000_000__000_000__000_000 // one hundred million million millions!
0x4000_0000_0000_0000
0.000_000_000_01
0x00_14_22_01_23_45 // MAC address
Separators are not allowed at the start of a number (this would be parsed as an identifier), at the end of a number, or adjacent to another character in a number, like ., x, or the e in scientific notation.
- Breaking Change #56065: The context used by the compiler and analyzer to perform type inference on the operand of a throw expression has been changed from the "unknown type" to Object. This makes the type system more self-consistent, because it reflects the fact that it's not legal to throw null. This change is not expected to make any difference in practice.
Libraries
dart:io
- Breaking Change #52444: Removed the Platform() constructor, which has been deprecated since Dart 3.1.
- Breaking Change #53618: HttpClient now responds to a redirect that is missing a "Location" header by throwing RedirectException, instead of StateError.
dart:js_interop
- Added constructors for JSArrayBuffer, JSDataView, and concrete typed array types e.g. JSInt8Array.
- Added length and []/[]= operators to JSArray.
- Added toJSCaptureThis so this is passed in from JavaScript to the callback as the first parameter.
- Added a static from method on JSArray to create a JSArray from a given JavaScript iterable or array-like object.
Tools
CFE
- Breaking Change #56466: The implementation of the UP and DOWN algorithms in the CFE are changed to match the specification and the corresponding implementations in the Analyzer. The upper and lower closures of type schemas are now computed just before they are passed into the subtype testing procedure instead of at the very beginning of the UP and DOWN algorithms.
Dart format
- Preserve type parameters on old-style function-typed formals that also use this. or super..
- Correctly format imports with both as and if clauses.
Wasm compiler (dart2wasm)
- The condition dart.library.js is now false on conditional imports in dart2wasm. Note that it was already a static error to import dart:js directly (see #55266).
Pub
- Support for workspaces. This allows you to develop and resolve multiple packages from the same repo together. See https://dart.dev/go/pub-workspaces for more info.
- New command dart pub bump. Increments the version number of the current package.
For example: dart pub bump minor will change the version from 1.2.3 to 1.3.0.
- New validation: dart pub publish will warn if your git status is not clean.
- New flag dart pub upgrade --unlock-transitive.
- dart pub upgrade --unlock-transitive pkg, will unlock and upgrade all the dependencies of pkg instead of just pkg.
Analyzer
- Add the use_truncating_division lint rule.
- Add the experimental omit_obvious_local_variable_types lint rule.
- Add the experimental specify_nonobvious_local_variable_types lint rule.
- Add the experimental avoid_futureor_void lint rule.
- Add quick fixes for more than 14 diagnostics.
- Add new assists: "add digit separators", "remove digit separators", and "invert conditional expression".