History of Flutter & Dart #

The history of software technology shows that the best development tools are always born from engineers’ frustration with the tools that already exist. Flutter and Dart are no exception. Tracing Flutter’s development history not only helps you understand how the framework works today, but also why certain architectural decisions were made. We’ll look at how the Dart programming language transformed from a web alternative into a modern cross-platform language, how an experimental project called “Sky” was born from the Chrome browser engine, and the timeline of major releases that carried Flutter to its current peak of industry popularity.

The Birth of Dart (2011): Looking for a JavaScript Successor #

Before Flutter was even a thought in anyone’s mind, Google had already developed a programming language called Dart. In the early 2010s, Google’s large-scale web applications like Gmail, Google Docs, and Google Maps were becoming increasingly complex and hard to manage with standard JavaScript. At that time, JavaScript didn’t have a class-based OOP system, built-in modular modules, or strong type safety support (ES6 features were only standardized a few years later).

Google engineers faced real problems with the scalability and performance of JavaScript code when worked on by hundreds of developers in one large project. To solve this, Google tasked Lars Bak (the lead architect behind Google Chrome’s V8 JavaScript engine) and Kasper Lund with designing a new programming language.

That language was named Dart and was unveiled to the public at the GOTO conference in Aarhus, Denmark, on October 10–12, 2011. Dart’s initial goals were very specific:

• To be an alternative to JavaScript for enterprise-scale web development.
• To provide an execution engine (virtual machine) far faster than the JavaScript engines of the time.
• To offer superior development tooling through an optional type system (optional typing).

Although Dart 1.0 was released stably in November 2013, adoption by the global web community was very slow. The web community at the time was reluctant to adopt a new language that required a special browser to run (Google briefly experimented with embedding the Dart VM in Chromium, but eventually scrapped the plan to focus on Dart-to-JavaScript compilation). JavaScript kept improving with the arrival of the ECMAScript 2015 (ES6) standard, which made Dart’s future uncertain. However, the failure to gain adoption in the web sector actually paved the way for Dart’s biggest transformation when a new project team at Google was looking for a language suitable for their revolutionary rendering system.

The Birth of Project “Sky” (2015): Chasing the 120 FPS Limit #

In 2014, a group of engineers on the Google Chrome team, led by Eric Seidel, began experimenting with a radical idea:

“What if we removed all the legacy web technology baggage (like HTML documents, CSS cascades, and decades of backward compatibility) from the WebKit/Blink rendering engine, and then saw how fast we could render content?”

This experiment produced an extraordinary discovery. By discarding all the complexity of the HTML/CSS parsers and focusing purely on dynamic graphics rendering, they could draw web pages at unprecedented speeds. This experimental project was named “Sky” and was tested on the Android operating system.

At the 2015 Dart Developer Summit, the “Sky” team demonstrated an Android app demo capable of rendering consistently at 120 frames per second (FPS). The demo stunned the industry, because mobile cross-platform frameworks of the time (like Cordova) were still struggling to hit a stable 30 FPS due to the limitations of the OS’s built-in browser rendering engine.

For the “Sky” project to transform into a productive app development framework, the team needed a programming language that met very strict technical criteria:

1. Support for Two Compilation Modes: The language had to support Just-in-Time (JIT) compilation for rapid development and Ahead-of-Time (AOT) for production release execution speed.
2. Very Fast Object Lifecycles: The declarative UI paradigm requires thousands of new widgets to be created and destroyed every second while the UI rebuilds. The language needed a next-generation Garbage Collector (GC) optimized for short-lived memory allocations without causing micro-stutter (stuttering render queues).
3. Thread Safety Without Overhead: To avoid race conditions and thread lock overhead that hurt frame rates, the language had to support a concurrency model based on isolated memory.

Dart turned out to be the only language in the world that met all three criteria. The Dart team’s commitment to modifying their compiler to meet the specific needs of the “Sky” rendering team sealed this historic collaboration. Project “Sky” was eventually renamed Flutter and announced officially to the public.

Major Development Timeline of Flutter & Dart #

Flutter’s evolution from an internal Google experiment to a cross-platform market leader is summarized in the timeline diagram below:

flowchart TD
    subgraph EraAwal["Foundation & Experiment Era"]
        D11["2011: Dart Unveiled"] -->|"Enterprise Web Focus"| D13["2013: Dart 1.0 Stable"]
        D13 -->|"Pivot to Client-Side"| S15["2015: Sky Project (Android 120 FPS)"]
    end

    subgraph EraStabilisasi["Mobile & Multi-Platform Stability Era"]
        S15 -->|"Alpha & Beta Phase"| F18["2018: Flutter 1.0 (Mobile Stable)"]
        F18 -->|"Dart 2.0: Strong Typing"| F21["2021: Flutter 2.0 (Web & Desktop Stable)"]
    end

    subgraph EraModern["Modern Performance & AI Era"]
        F21 -->|"Dart 2.12: Null Safety"| F22["2022: Flutter 3.0 (6 Platforms Stable)"]
        F22 -->|"Migration to Impeller"| F23["2023: Flutter 3.10 & Dart 3.0 (Sound Null Safety)"]
        F23 -. "Wasm Compilation & Gemini AI" .-> F26["2024 - 2026: Wasm Acceleration Era"]
    end

    style D11 stroke:#0288d1,stroke-width:2px
    style S15 stroke:#0288d1,stroke-width:2px
    style F18 stroke:#388e3c,stroke-width:2px
    style F21 stroke:#388e3c,stroke-width:2px
    style F22 stroke:#388e3c,stroke-width:2px
    style F23 stroke:#f57c00,stroke-width:2px
    style F26 stroke:#f57c00,stroke-width:2px

Each era transition above marks a shift in Google’s development focus: from technical proof of concept, to ecosystem expansion, to high-performance architecture optimization.

Why Did Google Choose Dart for Flutter? #

Google’s decision to use Dart is often questioned by new developers who are more familiar with JavaScript or Kotlin. However, if you look at it from a compiler and runtime engineering perspective, Dart has unique characteristics that make it the perfect partner for Flutter:

JIT (Just-in-Time) vs AOT (Ahead-of-Time) Compilation #

Dart is one of the few programming languages that flexibly separates its compiler architecture to solve two different problems:

flowchart TD
    subgraph DevMode["1. Development Mode (JIT)"]
        CodeDev["New Dart Code"] -->|"Compiled Instantly (Incremental)"| VM["Dart VM (JIT Runtime)"]
        VM -->|"State Change Injection"| HotReload["Hot Reload (< 1 Second)"]
    end

    subgraph ProdMode["2. Production Release Mode (AOT)"]
        CodeProd["Final Dart Code"] -->|"Fully Compiled"| AOTCompiler["AOT Compiler"]
        AOTCompiler -->|"Pure Machine Binary"| Bin["ARM / x64 Machine Code"]
        Bin -->|"Direct Execution without VM"| SmoothRun["Smooth Performance & Fast Boot"]
    end

    style DevMode stroke:#0288d1,stroke-width:2px
    style ProdMode stroke:#388e3c,stroke-width:2px

• During Development (JIT): Code is compiled dynamically inside the Dart VM running on an emulator or physical device. This enables the Hot Reload feature, where code changes are injected into the VM instantly (usually under a second) without destroying or resetting the app’s memory state.
• During Production (AOT): When you build a release app, the Dart compiler converts all code into pure machine code (ARM32/ARM64 for mobile, x64 for desktop). The result is an app that boots very quickly and runs stably without script interpretation overhead.

Concurrency Using Isolates #

Unlike Java or C++ which use shared-memory multi-threading (where different threads share the same memory addresses and are prone to deadlocks or race conditions), Dart uses the Isolate model.

Each Isolate runs independently with its own memory allocation and event loop. Isolates don’t share memory directly; communication between isolates is done by sending messages to each other (message passing).

• Benefit for UI: Flutter runs the UI and layout process exclusively on the Root Isolate. Because no other thread can forcibly modify or lock this UI memory, the Flutter UI is free from stuttering caused by memory lock contention.

Generational Garbage Collector (GC) #

Widgets in the declarative paradigm are disposable. Flutter constantly creates new widget objects when updating the UI. The Dart VM supports this need with a highly efficient generational garbage collection system. New objects are placed in the New Space area, which is cleaned up very quickly. If an object survives several GC cycles, it gets promoted to the Old Space. This minimizes memory cleanup pauses so they don’t interfere with the screen’s vertical frame synchronization (V-sync).

Major Release Milestones #

Since its official launch, Flutter has gone through several major release milestones that expanded its functionality and strengthened its position in the industry:

1. Flutter 1.0 (December 2018): Declaration of Production Readiness #

Released in London in December 2018, this version marked the stabilization of Flutter’s core APIs. Google assured the industry that the base APIs wouldn’t undergo drastic changes in the future. During this phase, industry adoption began to surge, led by large-scale engineering teams like Alibaba and Tencent.

2. Flutter 2.0 (March 2021): The Multi-Platform & Null Safety Era #

This release changed Flutter’s definition from a mobile framework to a multi-platform framework.

• Stable Web Support: Allows Flutter code to be compiled to standard HTML/CSS/JS to run in browsers.
• Desktop Support Preview: Started official integration with macOS, Windows, and Linux platforms.
• Sound Null Safety: Dart 2.12 was introduced with absolute null type safety. This type system ensures variables can’t be null unless you explicitly declare them as such, eliminating the class of NullPointerException bugs that are every developer’s nemesis.

3. Flutter 3.0 (May 2022): Six Stable Platforms #

Announced at Google I/O 2022, this release marked full stabilization of support for six major platforms under the same release codebase: Android, iOS, Web, Windows, macOS, and Linux.

4. Engine Transition: From Skia to Impeller (2023 - Present) #

For years, Flutter relied on Skia as its third-party 2D graphics library. Although very reliable, Skia had one weakness on the iOS platform: it compiled shaders dynamically while the app ran (runtime shader compilation). This caused small stutter/jank issues when custom animations were first run by users.

To permanently solve this problem, the Flutter team built a new graphics engine from scratch called Impeller.

• Impeller compiles shaders Ahead-of-Time (AOT) when the app is built.
• Starting with Flutter 3.10 (May 2023), Impeller is enabled by default on iOS.
• Google continues expanding Impeller’s default support to the Android platform (Vulkan/OpenGL APIs) to deliver smooth UI transition animations without runtime compilation hitches.

The Evolution of Dart: Becoming a Modern Multi-Platform Language #

As the language powering Flutter, Dart continues to evolve, absorbing modern features from other programming languages without sacrificing compilation speed.

The arrival of Dart 3.0 made writing logic in Flutter much more concise. For example, Pattern Matching lets you map app state declaratively and more safely, similar to the code style in modern Kotlin or Swift.

Summary #

• The Origins of Dart (2011) — Initially designed by Lars Bak and Kasper Lund as a structured JavaScript alternative for large-scale web applications.
• Project “Sky” (2015) — Born from a Google Chrome team experiment that discarded legacy web technology baggage to achieve 120 FPS rendering on Android.
• A Perfect Collaboration — Dart was chosen for its JIT compilation (for Hot Reload) and AOT (for release performance), its Isolate concurrency model, and a Garbage Collector optimized for dynamic widgets.
• Stable Release 1.0 (2018) — The initial milestone of mass production readiness for the Android and iOS mobile operating systems.
• The 2.0 & 3.0 Multi-Platform Leap — Expanded stable support to six platforms at once and introduced absolute type safety features (Sound Null Safety).
• The Impeller Engine Innovation — Replaced Skia to pre-compile shaders AOT, permanently eliminating graphics stutter on iOS and Android devices.

← Previous: What is Flutter?   Next: Problems Flutter Solves →