Isolates in Flutter

Mariam Mohmed — Thu, 25 Sep 2025 14:53:14 +0000

What is an Isolate?

An Isolate is basically a thread 🧵 in Dart/Flutter, but with one important difference: each isolate has its own memory space 💾 and its own event loop🔄.
This means isolates don’t share variables or data with the main thread directly. Instead, they communicate by sending messages ✉️.

An isolate is an independent worker that runs in its own memory heap.
Isolates do not share memory, unlike threads in other languages.
They communicate by sending messages through ports.

👉 Before talking about isolate lets take a look about Threads

A Thread is the smallest unit of a process that can be scheduled by the operating system. Threads allow concurrent execution within a
program, enabling efficient use of CPU resources.

🟢 Types of Threads

1. User Threads
User threads are managed entirely by the user-level libraries rather than the operating system. They are fast to create and manage but may suffer from performance issues since the OS is unaware of them.
2. Kernel Threads
Kernel threads are managed directly by the operating system. They provide better performance for multiprocessing systems but are more expensive to create and manage compared to user threads.
3. Hybrid Threads
Hybrid threading models combine user threads and kernel threads. This allows applications to benefit from the efficiency of user threads while still leveraging OS-level thread management.

Dart does not have traditional threads like Java or C++. Instead, Dart uses Isolates to achieve concurrency and parallelism. Each isolate has its own memory and event loop, preventing data races.

🟢Types of Thread-like Mechanisms in Dart:

1.Event Loop (Definition)

The Event Loop in Dart/Flutter is like a manager that 
 schedules and    runs your code step by step.

It makes sure:

All synchronous code runs first.
Then it checks special queues and processes them in order.

📦 The Two Queues in Dart

Microtask Queue 🥇 (higher priority)
Small, high-priority tasks.

Examples:

scheduleMicrotask(...)
Code after an await

📝 Execution Order

1.Run all synchronous code first.
2.Then check the Microtask Queue → run everything there until it’s empty.
3.Then take one task from the Event Queue, run it, and before moving
to the next event, check the Microtask Queue again.

⚡ Example

import 'dart:async';

void main() async {
  print("Start"); // sync
  scheduleMicrotask(() => print("Microtask 1"));
  Future(() => print("Future 1"));
  scheduleMicrotask(() => print("Microtask 2"));
  Future(() => print("Future 2"));
  await Future(() => print("Future 3 with await"));
  print("After await"); // sync
  Future(() => print("Future 4"));
  scheduleMicrotask(() => print("Microtask 3"));
  print("End"); // (10) sync
}

📖 The Story of the Event Loop example

The program starts → "Start" speaks immediately (because sync code always goes first).
Suddenly, two little jobs jump into the Microtask Queue:

"Microtask 1"
"Microtask 2"

They’re waiting, but event loop promises:
👉 "Don’t worry, I’ll come back after I finish the sync stuff."

Now await Future 3 shows up and says:
👉 "Hey Event Loop, pause here
⏸️. Go finish all microtasks first, then run me."
So event loop executes:

"Microtask 1".
"Microtask 2" ✅ Then it runs "Future 3 with await".

After finishing "Future 3 with await", the await whispers:
👉 "Okay, now continue the code after me (After await) immediately as a microtask."
So → "After await" is printed.

Back to sync → "End" is printed.
Another microtask appears: "Microtask 3", so event loop runs it.
Finally, the event loop looks at the Event Queue and runs the futures one by one:

"Future 1"
"Future 2"
"Future 3"


✅ Expected Output         
Start
Microtask 1
Microtask 2
Future 3 with await
After await
End
Microtask 3
Future 1
Future 2
Future 4

Isolates

True parallelism in Dart.
Each isolate has its own memory and runs independently.
Good for CPU-intensive tasks such as JSON parsing, encryption, or image processing.

🤔 Why Do We Need Isolates?

In Dart/Flutter, there is only one main thread (isolate) that runs your app.
This isolate handles UI rendering, events, and logic.
👉 Problem:
If you do heavy work (like parsing a huge JSON, image processing, compressing audio and video files, or encryption) on the main isolate, the UI will freeze 🥶 because the event loop is busy.

✅ Solution: Isolates

An isolate is like a separate worker (a new thread).
Each isolate has its own memory & event loop (they don’t share memory).
They talk to each other using message passing (like sending letters 📩).
So, when you have heavy tasks, you can send the job to another isolate, and your main isolate stays free to keep the UI smooth 🖼️✨.

🔎 How Isolates Work in Dart/Flutter

1. Each Isolate = Separate World 🌍

Every isolate has its own memory, its own event loop, and even its own microtask & event queues.
Unlike threads in some languages, Dart isolates don’t share memory → so no race conditions ⚡.

2. Communication = Messages Only 📩

Since isolates don’t share memory, they communicate by sending messages through ports (SendPort & ReceivePort).
Example:
- Main isolate: “Hey worker, please parse this JSON.”
- Worker isolate: “Done ✅, here’s the result.”

3. Event Loop Inside Each Isolate 🔄

Each isolate runs its own event loop (just like the one we discussed earlier).
That means inside an isolate, you still have: sync code → microtasks → event queue.

🟢 Types of Isolates in Dart/Flutter

1. Main Isolate 🏠

The default isolate where your app starts.
Responsible for:
- Running your sync/async code.
- Managing the event loop.
- Rendering the UI in Flutter.
⚠️ If you run heavy tasks here → the UI will freeze and here came the advantage of worker isolates

2. Worker Isolates 👷‍♂️

These are isolates you create manually using:
- Isolate.spawn() 🛠️ (classic way – requires SendPort/ReceivePort).

import 'dart:isolate';

// This function will run inside the new isolate
void heavyComputation(SendPort sendPort) {
  int result = 0;
  for (int i = 0; i < 50000000; i++) {
    result += i;
  }

  // Send result back to the main isolate
  sendPort.send(result);
}

void main() async {
  // Create a ReceivePort to get messages from the spawned isolate
  final receivePort = ReceivePort();

  // Spawn a new isolate and pass the SendPort
  await Isolate.spawn(heavyComputation, receivePort.sendPort);

  // Listen for messages from the isolate
  receivePort.listen((message) {
    print("Result from isolate: $message");
    receivePort.close(); // close after receiving
  });

  print("Main isolate is free to do other work...");
}

Isolate. Run()⚡(new in Dart 3 – simpler, returns the result directly).

import 'dart:isolate';

Future<void> main() async {
  print("Main isolate started");

  // Run a heavy computation in a separate isolate
  final result = await Isolate.run(() {
    int sum = 0;
    for (int i = 0; i < 100000000; i++) {
      sum += i;
    }
    return sum; // result sent back automatically
  });

  print("Result from isolate: $result");
  print("Main isolate is still responsive!");
}

Purpose: run heavy computations without blocking the main isolate. They communicate with the main isolate via message passing.

3. Background Isolates (via Flutter plugins) ⚙️

Some Flutter plugins internally use isolates to do heavy work. You don’t create these isolates yourself — the library manages
Example: the compute() function in Flutter runs a callback in a background isolate:

import 'package:flutter/foundation.dart';
int heavyCalculation(int value) {
  var sum = 0;
  for (var i = 0; i < value; i++) sum += i;
  return sum;}
void main() async {
  final result = await compute(heavyCalculation, 1000000);
  print(result); // 499999500000

4. Service Isolates 🛰️ (rarely used directly)

Created by the Dart VM or the Flutter engine itself.
Example: the VM service isolate used by IDEs (VS Code/Android Studio) for debugging & hot reload.
You don’t create these — they are internal.

✨ Summary

-  Main Isolate → the core isolate (runs UI + logic).
-  Worker Isolate → created by you for heavy tasks.
-  Background Isolate → used internally by plugins or compute().
-  Service Isolate → created by the Dart VM/engine for 
  debugging & tools.

⚡ Performance Considerations of Isolates in Dart

When working with Dart and Flutter, isolates are powerful for handling concurrency without blocking the main thread.
But like any tool, they come with trade-offs. Let’s break down the key performance aspects 👇

🚀 1. Startup Cost

Spawning a new isolate takes more time than using async/await.
This is because a new memory heap and event loop need to be created.

🧠 2. Memory Usage

Each isolate has its own memory space (heap + garbage collector).
This prevents data races, but increases RAM consumption.

🔄 3. Communication Overhead

Isolates don’t share memory directly.
They use SendPort / ReceivePort to pass messages.
Large objects require serialization/deserialization, which adds cost.

💪 4. CPU Utilization

Isolates enable true parallelism on multi-core processors.
Perfect for CPU-bound tasks like:
Image processing
File parsing
Heavy mathematical computations

⏳ 5. Latency

There’s a slight delay when spawning an isolate.
That’s why isolates are best for long-running / heavy tasks, not quick lightweight jobs.

📈 6. Scalability

You can leverage all CPU cores by distributing work across isolates.
However, message passing can become a bottleneck if not designed carefully.

🌍 Platform Differences of Isolates

🖥️ Isolates on Desktop & Mobile

✅ Full isolate support is available, just like on mobile.

💡 Particularly useful for desktop apps that need to handle large files:

PDF parsing
Image editing
Data analysis / processing
📱 Mobile (Android/iOS)
Full support for isolates.
🌐 Web
⚠️ Limited support → relies on Web Workers.
Browsers don’t allow native multi-threading like mobile/desktop.
Some isolate APIs are not fully available in web builds.

🚀 Practical Use Cases of Isolates in Flutter

In Flutter, isolates are not something you use every day — but when you need them, they can be life-savers.
They shine whenever your app has to do heavy work that could block the UI thread.

Let’s explore some practical situations where isolates make a big difference 👇

🧮 1. Heavy Computations

Building a math app that calculates prime numbers or solves complex equations?
👉 Running this on the main thread will freeze your UI.
✅ Offload the work to an isolate so your UI stays smooth while the computation runs in parallel.

🖼️ 2. Image Processing

Photo editing apps often need to resize, filter, or compress large images.
These tasks are CPU-intensive.
By using isolates, you can process images in the background without lagging animations or user interaction.

📂 3. File Parsing & Encoding

Opening a huge JSON, CSV, or PDF file on the main thread = lag city 🚧.
Instead, send the file to an isolate:

Parse it
Compress it
Send back the result once ready.

🔐 4. Encryption & Security

Encryption, hashing, or decryption are heavy tasks.
👉 By running them in an isolate, your app remains responsive while protecting user data.

⚙️ 5. Background Services

Tasks like:

Downloading large files
Syncing data
Offline processing

…can all live inside isolates.
✅ This keeps the main isolate free to handle user actions.

📊 6. Real-time Data Processing

Apps that process live data streams (e.g., stock market updates, sensor data, chat apps) can use isolates to crunch numbers in real time, without blocking UI updates.

🖥️ 7. Server-Side Dart

On the backend, isolates shine even more:
Each isolate can handle requests independently
You can fully utilize multiple CPU cores
Improves scalability of Dart servers

🌍 Real-World Scenarios for Isolates in Flutter

📂 Scenario: Large JSON Parsing in an E-commerce App
**🎯 The Problem**

Imagine you are building an e-commerce app (like Amazon or Noon).
When the user opens the app, it makes an API call to fetch a huge product list.
The API returns a massive JSON file with thousands of products.
This JSON needs to be parsed (decoded) into Dart objects before the UI can display them.

👉 If you parse this JSON on the main isolate:

The UI will freeze (the app becomes unresponsive).
The user might even think the app has crashed.

✅ The Solution → Use an Isolate

Send the raw JSON string to a separate isolate.
The isolate does the heavy decoding and mapping.
Once finished, it sends the parsed product list back to the main isolate.
The UI stays smooth while the parsing happens in the background.

import 'dart:convert';
import 'dart:isolate';
void main() async {
  // Simulate a large JSON string
  String largeJson = '{"products": ${List.generate(100000, (i) => '{"id": $i,   "name": "Product $i"}')}}';
  // Run JSON parsing in an isolate
  final parsedData = await Isolate.run(() {
    final data = jsonDecode(largeJson);
    return data['products'];
  });

  print("Parsed ${parsedData.length} products ✅");
}

📌 The Result

User opens the app → the UI remains responsive.
The isolate processes the JSON in the background.
Once done, the isolate sends the result back → the UI displays products smoothly.

⚡ Error Handling in Dart/Flutter Isolates

🔹 1. Basic Error Handling with Isolate.spawn()

import 'dart:isolate';

void heavyTask(SendPort sendPort) {
  try {
    // simulate error
    throw Exception("Something went wrong in isolate 🚨");
  } catch (e, st) {
    // send error back to main isolate
    sendPort.send({"error": e.toString(), "stack": st.toString()});
  }
}

void main() async {
  final receivePort = ReceivePort();

  // Spawn isolate
  await Isolate.spawn(heavyTask, receivePort.sendPort);

  // Listen for messages
  receivePort.listen((message) {
    if (message is Map && message.containsKey("error")) {
      print("❌ Error from isolate: ${message["error"]}");
      print("📌 Stacktrace: ${message["stack"]}");
    } else {
      print("✅ Result: $message");
    }
  });
}

🔹 2. Using compute (simplified error handling)

import 'package:flutter/foundation.dart';

int riskyComputation(int n) {
  if (n < 0) throw Exception("Negative number not allowed 🚫");
  return n * 2;
}

void main() async {
  try {
    final result = await compute(riskyComputation, -5);
    print("✅ Result: $result");
  } catch (e) {
    print("❌ Caught error: $e");
  }
}

⚠️ Limitations of Isolates in Dart/Flutter

While isolates are powerful for handling CPU-intensive tasks, they come with some important limitations you should be aware of 👇

1️⃣ No Shared Memory

Each isolate has its own memory heap.
You cannot directly share variables between isolates.
Communication must happen via message passing (using SendPort/ReceivePort when working with Isolate.spawn).

✅ This design prevents data races, but makes sharing data less efficient.

2️⃣ Serialization Overhead

when sending messages between isolates, Dart performs serialization & deserialization.
For large data structures (like huge JSON or images), this adds noticeable overhead.
This means isolates are great for computation, but less ideal for passing around giant objects frequently.

3️⃣ Startup Cost

Spawning a new isolate is heavier than creating a new Future or using async/await.

embed Why? Because each isolate needs:

Its own heap
Its own event loop

👉 Best used for long-running or CPU-heavy tasks, not for small or short-lived operations.

4️⃣ Limited Web Support
On Flutter Web, isolates rely on Web Workers.

Some APIs available in mobile/desktop isolates are not fully supported on web.

Example: Isolate.spawn has limitations compared to compute or Isolate.run.

5️⃣ Debugging Complexity

Since each isolate runs in a separate memory space, debugging can be harder.
You don’t have direct stack traces across isolates.
Error handling requires explicit mechanisms (SendPort, addErrorListener).

DEV Community: Mariam Mohmed