Isolates & CPU-Bound Concurrency — Flutter Course

What you'll learn

Keep frames responsive by measuring CPU work and moving justified computations to message-passing isolates. The lesson turns the APIs into a repeatable engineering workflow instead of a collection of isolated snippets.

By the end of this lesson, you'll be able to:

Apply Concurrency vs parallelism in a production-shaped Flutter feature
Apply Main isolate in a production-shaped Flutter feature
Apply Isolate.run in a production-shaped Flutter feature
Apply Message passing in a production-shaped Flutter feature

Core mental model

Connect each API to the decision it supports. Flutter code stays maintainable when state, ownership, lifecycle, and platform boundaries are explicit.

Concept	What it means	Decision rule
Isolate	An independent Dart execution context with separate memory	Use for CPU work that measurably blocks responsiveness
Message passing	Isolates exchange sendable values instead of shared mutable memory	Keep payloads compact and contracts serializable
Transfer cost	Spawning and copying data consume time and memory	Benchmark the full handoff, not only the worker function

Professional workflow

Work in small vertical slices and keep behavior observable from the first iteration.

Define the measured background computation boundary: user goal, inputs, visible states, ownership, and expected failures.
Build the smallest working vertical slice with typed data and explicit dependencies.
Represent loading, empty, success, and failure behavior where the feature can encounter them.
Verify logic away from the UI, then exercise the rendered behavior at its public boundary.
Inspect lifecycle, accessibility, performance, security, and platform behavior before widening the feature.
Refactor only after behavior is protected by repeatable evidence.

Protect the frame

Keep build methods predictable, move side effects to explicit owners, and measure before introducing caches, isolates, or architectural layers.

Guided Flutter lab

Build a focused measured background computation slice

This compact example keeps the important ownership and data-flow decisions visible so the behavior is easy to extend and test.

lib/search_index.dart

import 'dart:isolate';

Future<Map<String, int>> buildIndex(List<String> lessons) {
  return Isolate.run(() {
    final index = <String, int>{};
    for (final lesson in lessons) {
      for (final word in lesson.toLowerCase().split(RegExp(r'\W+'))) {
        if (word.isNotEmpty) index.update(word, (n) => n + 1, ifAbsent: () => 1);
      }
    }
    return index;
  });
}

Production practice

Contract

Define the measured background computation inputs, outputs, owner, lifecycle, visible states, and platform assumptions before selecting APIs or packages.

Verification

Protect pure rules with unit tests and the rendered public contract with widget or integration evidence; include one unavailable or failure case.

Operations

Keep dependencies replaceable, log actionable context without user secrets, and measure user-visible behavior before optimizing.

Common failure mode

Moving tiny work to an isolate can be slower than keeping it on the main isolate because spawn and message-transfer costs dominate.

Independent workshop

Extend the guided lab into a review-ready measured background computation feature that fits the running course portfolio app.

Your finished workshop must include:

Concurrency vs parallelism
Main isolate
Isolate.run
Message passing
Transfer costs
Automated verification and a short design note

Definition of done

Demonstrate the happy path, an empty or unavailable state, and at least one failure path. Add an automated check and a short note explaining one design decision.

Recap & quick check

Key takeaways

Isolate: Use for CPU work that measurably blocks responsiveness
Message passing: Keep payloads compact and contracts serializable
Transfer cost: Benchmark the full handoff, not only the worker function

Quick check

1. Which rule best applies to Isolate?

2. Which rule best applies to Message passing?

3. Which rule best applies to Transfer cost?

Next: Packages, Tooling & Dart Testing