flutter_isolate_web

KO | EN

gitlite — search

#typescript #ai-agents #ai #dsh-plugin #deepseek-harness #open-source #cli #claude-code #codex #developer-tools #react #windows

flutter_isolate_web

★ 69 Open GitHub ↗

Unified interface to isolates and web workers.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Flutter Isolate Web

The title is a misnomer. Of course, there are no isolates in Flutter Web. What this code provides
is a unified interface to isolates *and* web workers so that each platform can use its own.
It's not a package on pub.dev and it won't be because you can't use it out of the box just like
a regular package or plugin. You have to copy it into your own code and modify it to suit your needs.

## Dependencies

It depends on:

* [isolate_handler](https://pub.dev/packages/isolate_handler), this is what provides
the isolates with communication already in place,

* [js](https://pub.dev/packages/js), this is what provides the connection to JavaScript.

## Usage

Create a worker first:

```dart
final worker = BackgroundWorker();
```

and start it when needed:

```dart
worker.spawn(
  doWork,
  name: 'some-unique-name',
  onInitialized: onInitialized,
  onFromWorker: onReceive,
);
```

You can start any amount of workers, just give a unique name to all so that you can reference them later when sending
or receiving messages.

`doWork()` is a function taking a `Map` argument (the context of the isolate/worker). As customary with standard isolates,
it has to be a top-level or static function. The most usual activity here is to start listening to messages the isolate/worker
will receive from the main app (the actual message structure is completely up to you, this is just an example):

```dart
void doWork(Map<String, dynamic> context) {
  worker.listen((args) {
    switch (args['command']) {
      case 'start':
        // worker starts its job
        break;
    }
  }, context: context);
}
```

When the isolate/worker actually gets initialized, the main app will be notified. You might simply use this to send a message
back to the worker to start the actual work (the actual message structure is completely up to you, this is just an example):

```dart
void onInitialized() {
  worker.sendTo('some-unique-name', {
    // tell the worker to start its job
    'command': 'start',
    'data': ...,
  });
}
```

There is an important difference between the two that must be understood. `doWork()` runs in the worker/isolate,
this is the main entry point of the worker/isolate code. `onInitialized` and `onFromWorker` run in the main app,
this is where the main app receives messages from the workers/isolates.

This second is the main messaging mechanism. Make sure the isolate/worker also knows the main `worker` object
and its own unique name (the name was returned to the `entryPoint()` as `context['name']`) because it needs those
to send its messages back:

```dart
// isolate/worker sends to main app:
worker.sendFrom('unique-name', message);

// main app sends to isolate/worker:
worker.sendTo('unique-name', message);

// main app receives from isolate/worker:
void onReceive(T message) {
  //...
}
```

If you need to kill the worker/isolate, use:

```dart
worker.kill('unique-name');
```

To kill all of them, use the `names` list:

```dart
for (String name in worker.names) worker.kill(name);
```

## Web

Everything described above works on mobile with isolates. However, the Flutter Web side is not that nice yet.

If you have the JavaScript code you want to run when compiling your app for the web, it works. Call your code with
the `importScripts()` in `worker_web.dart` and that's all. You can even do away with all that `createObjectUrlFromBlob`
stuff and construct the `Worker` directly with the JS file from your app assets or downloaded from a CDN. The same applies
if your isolate code from your mobile app is simple enough so that you can and want to replicate it in JavaScript.

The missing link in the chain is if you want to use the *same* Dart code you used for your isolate in your web worker.
If your code is free from dependencies, you could get away with simply compiling it with:

dart2js --libraries-spec=$HOME/flutter/bin/cache/flutter_web_sdk/libraries.json -o worker.js worker.dart

copying it to your assets and loading it. But we are unable to simply re-use our existing Dart code, even if it is actually
compiled to JavaScript, anyway. There's no way to compile part of your app (your isolate/worker) into a separate file and
to include it separately for the worker to use, and, by obvious limitation of web workers, we can't simply call into our
main app code from the worker, either.

### Intermediate solution for the web

The package also has a `worker_async.dart` file. This is an async solution to the problem. It implements the same interface,
so it can be used as is to make the isolate/worker scheme work on the web. It won't be a real web worker, though, it won't run
in parallel but it works. These "fake" workers will be called in the usual asnychronous way. While not yet the real McCoy,
it's a functional replacement.

flutter_isolate_web

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README