Isolates for heavy work

Waiting versus working

There are two kinds of slow. Waiting (for a network or a file) uses no CPU; async/await handles it perfectly on one thread. Working (calculating, parsing, compressing) uses the CPU continuously. While the main isolate is busy working, it cannot draw frames or respond to taps.

Flutter aims to draw a new frame about every 16 milliseconds (60 frames per second; even faster on 90 or 120 Hz screens). If one piece of work takes 200 ms on the main isolate, about a dozen frames are missed and the user sees the app stutter, called jank.

What is an isolate?

An isolate is Dart's unit of concurrency: an independent worker with its own memory and its own event loop. Isolates do not share memory, so there are no data races between them; they communicate by sending messages (copies of data). Your app's code normally runs on the main isolate.

Isolate.run

import 'dart:convert';
import 'dart:isolate';

List<dynamic> parseHugeJson(String text) => jsonDecode(text) as List<dynamic>;

Future<void> main() async {
  final bigText = '[${List.filled(200000, '{"id":1,"name":"item"}').join(',')}]';
  final items = await Isolate.run(() => parseHugeJson(bigText));   // runs on a new isolate
  print('Parsed ${items.length} items');                              // Parsed 200000 items
}

In Flutter you will also see compute(function, argument) from the foundation library, which does the same job and also works on the web (where it runs on the main thread, because the web does not support isolates in the same way).

When do you need it?

Rules of thumb

• Measure first with Flutter DevTools (module 9). Do not move everything into isolates "just in case".
• The function you run must be self-contained: it gets its input as an argument (copied) and returns a result (copied). It cannot touch your widgets or state.
• Sending very large objects between isolates costs copying time; send what you need.

Common mistakes

• Using isolates for network calls: unnecessary; they are already asynchronous.
• Trying to update UI or global state from inside the isolate function: it has its own memory.
• Expecting isolates to speed up small work: starting one has a cost.
• Blocking the UI with a long synchronous loop and blaming Flutter. Move the loop to an isolate.