Dart SDK

Dart is a strongly typed, productive language designed for high-quality applications across multiple platforms. It supports modern features like null safety and patterns.

Compilation Targets

Depending on your target platform, Dart uses different compilation technologies:

• Dart Native: Targets mobile, desktop, and server. It utilizes a Dart VM with JIT (just-in-time) compilation for development and an AOT (ahead-of-time) compiler to produce optimized machine code (ARM, x64, or RISC-V) for production.
• Dart Web: Targets the web. It uses dartdevc (development time compiler) for fast iteration and dart2js (production time compiler) for optimized JavaScript output. It also supports WebAssembly.

The analysis_server package implements the Dart Analysis Server (DAS). The server provides the underlying logic for both IDE-based development experiences (providing features like code completion, error highlighting, and refactoring) and command-line tools. Key command-line tools powered by the analysis server include:

• dart analyze: Used for static analysis of Dart code.
• dart fix: Used to automatically apply code fixes to resolve issues identified by the analyzer.

The Dart Web Developer Service (DWDS) enables developer tools designed for the native Dart VM to function with Dart Web applications. It acts as a proxy between tools using the Dart VM Service Protocol and execution environments (like Chrome) that use the Chrome DevTools Protocol.

DWDS is specifically designed for applications that are:

• Compiled with DDC (Dart Dev Compiler).
• Built or served with webdev.
• Running in the Chrome browser.

Dart Runtime Services is a collection of implementations based on package:dart_runtime_service. It provides a framework for creating Dart developer services with a shared frontend and pluggable backends. This architecture allows services to share common platform-agnostic behaviors while delegating specific protocol implementations to custom backends.

Common features provided by the shared frontend include:

• Launching and advertising a server
• Handling connections via multiple protocols (WebSockets, SSE, HTTP)
• Authentication code verification
• Notification routing via stream subscriptions
• Client-registered service extension routing
• DevTools hosting

The pkg/cfg package provides a Control Flow Graph (CFG) intermediate representation (IR) for Dart programs. It is designed to facilitate optimization passes performed on the CFG.

The package is structured into four main areas:

• front_end/: Handles the translation from the Kernel AST to the CFG.
• ir/: Contains the CFG/SSA (Static Single Assignment) IR and logic for computing its properties.
• passes/: Implements various optimization passes.
• utils/: Provides general-purpose utilities for CFG operations.

The package:dartpad library allows you to build web applications that provide a browser-based prototyping environment for Dart and Flutter.

It manages two primary components:

1. A Worker: A dart2wasm compiled Web Worker that provides an in-memory file system, the Dart LSP server, the Dart Development Compiler (DDC), and a subset of dart pub commands for dependency resolution.
2. A Sandbox: An isolated iframe that runs, hot-reloads, and hot-restarts DDC-compiled Dart code, while proxying console output and unhandled exceptions to the host application.

To build a custom experience, you launch the worker, connect the language server to your editor, compile code, and instruct the sandbox to execute it.

The dart2bytecode package is a Dart bytecode compiler.

Warning: This package is currently experimental. It is not published as a standalone package and is not included in the standard Dart SDK. Users should avoid depending on this package in production environments as it is subject to breaking changes or complete removal without notice.

Dart Kernel is a high-level intermediate language derived from Dart. It serves as an intermediate format for whole-program analysis, transformations, and as an input for code generation and execution backends.

Key characteristics:

• In-memory representation: Implemented using Dart structures.
• Serialization: Supports both binary and text formats.
• Stability Warning: Both the language and its implementations are currently unstable and under active development. There is no semver contract; developers should depend on specific individual versions rather than ranges.