What Dart is and where it runs

One Dart file printed 9007199254740993 on the Dart VM and 9007199254740992 after it was compiled to JavaScript. Same source, same SDK, two answers: that one digit is the quickest way to see what Dart is, a single language with several compilers behind it.

You will see where a Dart program can run, run one program on the VM, as JavaScript and as WebAssembly and explain the digit that differs, and read which version of the language a package gets from one line of its pubspec.yaml.

Dart is one typed language with several compilers

Dart is an open-source programming language from Google. Its own documentation calls it client-optimized: built for apps on phones, desktops and the web, where a fast edit-and-run cycle while you write and a fast start once you ship both matter. It is also the language of Flutter, the multi-platform toolkit for app interfaces, and it runs command-line tools and servers as well.

Three properties shape everything later in this track:

• Static types that are sound. The compiler checks that a variable’s value always matches its type, and you can usually leave the type out because Dart infers it.
• Null safety that holds at run time. A variable cannot hold null unless its type says so, and this sound null safetysound null safety: Dart's guarantee that a value whose type is not nullable is never null, checked by the compiler and still true while the program runs. A type allows null only when it says so, as String? does. still holds while the program runs.
• Managed memory. A garbage collector reclaims what the program no longer uses, so you never release memory by hand.

What makes Dart unusual is how many ways the same source can run. Step through what the SDK does with one file:

The Dart VMDart VM: The virtual machine that runs Dart programs from source during development, compiling them just in time; dart run uses it, and it makes hot reload and debugging possible. is the engine of development, and the other three are builds you ship. Whichever way the code runs, it needs a Dart runtime, which manages memory and performs the type checks that wait for run time, such as casts, so the guarantees above hold on every target.

The VM runs your code while you write it, and AOT builds ship it

While you write, dart run gives your file to the Dart VM, which compiles it as it runs. That is just-in-time compilationjust-in-time compilation: Compiling code while the program runs, as the Dart VM does during development, so that changed code can be compiled again and swapped into the running program.: the VM can recompile a part you changed while the program keeps its state, which is what hot reloadhot reload: Putting changed code into a program that is already running without restarting it, so it keeps its state; the Dart VM's just-in-time compiler makes it possible. in Flutter uses, and it collects the live data that Dart DevTools shows.

When the program is ready to ship, ahead-of-time compilationahead-of-time compilation: Compiling a whole program to machine code before it runs, as dart compile exe does; the result starts quickly and runs without the Dart SDK on the system it was built for. turns the whole program into ARM or x64 machine code first. The overview puts it as “Your AOT-compiled app launches with consistent, short startup time”: nothing is left to compile when it starts. For the web, the SDK has two production compilers: one to JavaScript and one to WebAssembly with WasmGCWasmGC: The garbage-collection extension of WebAssembly. dart compile wasm writes modules that rely on it, so they run only in browsers and runtimes that support it., the garbage-collection extension of WebAssembly.

dart compile takes the kind of output as a subcommand, and its documentation lists six:

The executable runs where it was built: an exe made on a Mac runs on Macs with the same kind of processor. The kernel file is the portable one, at the price of a slower start.

The same program can print two different answers

Here is the program from the start of this lesson. It adds 1 to 2^53, divides 1 by 3, and asks whether the sum is even:

// One program for three compilers: the Dart VM, dart2js and dart2wasm.
void main() {
  const big = 9007199254740992; // 2 to the power 53
  final next = big + 1;
  print('2^53 + 1 = $next');
  print('1 / 3 = ${1 / 3}');
  print('next is even: ${next.isEven}');
}

2^53 + 1 = 9007199254740993
1 / 3 = 0.3333333333333333
next is even: false

That run was the Dart VM. The next session builds the same file twice more, once with dart compile js and once with dart compile wasm, and runs both builds with Node.js. The small loader it uses for the WebAssembly build is the second file:

// Runs the WebAssembly build of main.dart in Node.js: compile the module,
// instantiate it with the companion runtime main.mjs, then call main.
import { readFile } from 'node:fs/promises';
import { compile } from './out/main.mjs';

const bytes = await readFile(new URL('./out/main.wasm', import.meta.url));
const app = await compile(bytes);
const instance = await app.instantiate({});
instance.invokeMain();

from session import files, run

# The same main.dart on the Dart VM, as JavaScript and as WebAssembly (both run by Node.js).
files("three/main.dart=main.dart", "three/run_wasm.mjs=run_wasm.mjs")
run(
    """
dart run main.dart
dart compile js -O2 -o out/main.js main.dart
node out/main.js
dart compile wasm -O2 -o out/main.wasm main.dart
node run_wasm.mjs
"""
)

$ dart run main.dart
2^53 + 1 = 9007199254740993
1 / 3 = 0.3333333333333333
next is even: false
$ dart compile js -O2 -o out/main.js main.dart
Compiled 10,737,774 input bytes (5,318,344 characters source) to 5,253 characters JavaScript in … seconds
$ node out/main.js
2^53 + 1 = 9007199254740992
1 / 3 = 0.3333333333333333
next is even: true
$ dart compile wasm -O2 -o out/main.wasm main.dart
Generated wasm module 'out/main.wasm', and JS init file 'out/main.mjs'.
$ node run_wasm.mjs
2^53 + 1 = 9007199254740993
1 / 3 = 0.3333333333333333
next is even: false

Side by side, the three runs printed this, and 1 / 3 came out as 0.3333333333333333 on all of them:

Only the JavaScript build lost the 3, and with it the program’s logic changed: it called an odd sum even. On native platforms an int is a signed 64-bit integer. JavaScript has one kind of number, a 64-bit floating-point value, so when Dart compiles to JavaScript both int and double become that number, and Dart’s number documentation states the consequence: an integer on the web keeps 53 bits of precision, and 2^53 and 2^53 + 1 map to the same value. The WebAssembly build printed the VM’s answer on this run. The division is the same everywhere, because a double is the same 64-bit floating-point format on every target.

The rounding is not limited to one value. Dart’s number page lists more expressions that differ on the web: 2^62 prints as 4611686018427387904 on native platforms and as 4611686018427388000 on the web, and 2^63, which wraps to -9223372036854775808 on native platforms, prints as 9223372036854776000 there. From −2^53 to 2^53, every integer is exact on every target.

Your SDK constraint chooses the language version

Every minor release of the SDK is also a version of the language, written with two numbers, such as 3.13. The Dart 3.13.5 SDK reads code at any language version from 3.13 back to 2.12, the first with null safety, and it picks one for each library. A package’s SDK constraintSDK constraint: The environment sdk entry of pubspec.yaml, such as ^3.13.0: the Dart SDK versions a package works with. Its lower bound also sets the package's language version. decides: the lower bound of environment: sdk: in pubspec.yaml is the package’s language versionlanguage version: The version of the Dart language a library is read with, written as major.minor, such as 3.13. A package's default is the lower bound of its SDK constraint.. sdk: ^3.12.0 means language 3.12, even on a newer SDK.

That is how a new feature arrives without breaking old code. Walk through what each Dart 3 release changed:

Primary constructors, the 3.13 feature, make a good test. The next session runs the same file in two packages, the first with sdk: ^3.12.0 and the second with sdk: ^3.13.0:

from session import files, run

# The same file in two packages: one says sdk: ^3.12.0, the other sdk: ^3.13.0.
files("versions/pc312=points_312", "versions/pc313=points_313")
run(
    """
cat points_312/pubspec.yaml
cd points_312
dart pub get --offline
!dart run bin/points.dart
cd ../points_313
dart pub get --offline
dart run bin/points.dart
"""
)

$ cat points_312/pubspec.yaml
name: points_312
environment:
  sdk: ^3.12.0
$ cd points_312
$ dart pub get --offline
Resolving dependencies...
Downloading packages...
Got dependencies!
$ dart run bin/points.dart
bin/points.dart:2:13: Error: The 'primary-constructors' language feature is disabled for this library.
Try removing the package language version or setting the language version to 3.13 or higher.
class Point(var int x, var int y);
            ^^^
bin/points.dart:2:24: Error: The 'primary-constructors' language feature is disabled for this library.
Try removing the package language version or setting the language version to 3.13 or higher.
class Point(var int x, var int y);
                       ^^^
bin/points.dart:2:12: Error: The 'primary-constructors' language feature is disabled for this library.
Try removing the package language version or setting the language version to 3.13 or higher.
class Point(var int x, var int y);
           ^
bin/points.dart:2:34: Error: The 'primary-constructors' language feature is disabled for this library.
Try removing the package language version or setting the language version to 3.13 or higher.
class Point(var int x, var int y);
                                 ^
[exit status 254]
$ cd ../points_313
$ dart pub get --offline
Resolving dependencies...
Downloading packages...
Got dependencies!
$ dart run bin/points.dart
x = 3, y = 4

Under 3.12 the compiler refused with “The ‘primary-constructors’ language feature is disabled for this library” and exit status 254, the status the dart command uses for a compile-time error. Under 3.13 the same file printed x = 3, y = 4. One file can also choose for itself: a // @dart = 3.12 comment before any code reads that library as language 3.12, while the rest of the package keeps its own version.

Practise: read the platform and the version

Work through these, then answer the questions below:

1. Change big + 1 to big + 2 in three/main.dart and predict all three lines of each target before you look back at the table. Every integer up to 2^53 has a JavaScript number of its own; between 2^53 and 2^54 only the even ones do.
2. A pubspec says sdk: '>=3.7.0 <4.0.0'. Write down its language version, and which features of the timeline it can and cannot use.
3. A colleague’s file starts with // @dart = 3.9. Name one feature from the timeline that file cannot use.

The questions come one at a time, with the weakest idea first:

Interview questions

Warm-up (fresher): What is the difference between JIT and AOT compilation in Dart?

Just-in-time compilation happens while the program runs: the Dart VM compiles code as it is needed, which lets it recompile a changed function and keep the program’s state, the basis of hot reload, and it gives debuggers and DevTools a live program to inspect. dart run and Flutter’s debug mode use it. Ahead-of-time compilation happens before the program runs: dart compile exe or a Flutter release build for Android or iOS turns the whole program into machine code for one operating system and processor, with a small Dart runtime for garbage collection and type checks. The AOT result starts quickly and the same way every time, and the machine that runs it needs no SDK, but it cannot be changed while it runs. So use JIT while you develop and AOT for what you ship.

Two longer questions of this module start from this lesson:

Key takeaways

• Dart is an open-source, statically and soundly typed, garbage-collected language from Google that runs on the Dart VM, as native machine code, as JavaScript and as WebAssembly.
• The VM compiles just in time while you develop, which enables hot reload; dart compile makes the ahead-of-time, JavaScript and WebAssembly builds you ship, and each of them still runs with a Dart runtime.
• On the web through JavaScript, an int is a 64-bit floating-point number with 53 bits of integer precision, so the JavaScript build printed 9007199254740992 where the VM and the WebAssembly build printed 9007199254740993.
• The lower bound of a package’s SDK constraint is its language version, a // @dart = x.y comment changes it for one file, and the 3.12 package refused the 3.13 primary constructor that the 3.13 package ran.