@@ -1,5 +1,18 @@
 # Changelog
 
+## 3.10.0
+
+### Performance
+
+- `encodeAVIF()` encodes in worker threads (`AVIFEncodeOptions.threads`, default: the processors available, at most
+  8; `1` for none), writing the same files: superblock rows are searched in a wavefront (each superblock after the one
+  above right of it), like libaom's row-based multithreading, so there is no loss in compression, and the loop filter
+  and CDEF trials run in parallel. A 1920x1080 photo takes 1.1 s instead of 2.1 s at effort 0, 1.7 s instead of 4.9 s
+  at effort 1 and 3.4 s instead of 14.2 s at effort 2 (8 threads, Ryzen 7 5800X). Works in Node (worker_threads),
+  Deno, Bun and browsers (Web Workers; bundlers like Vite pick up the worker's module). Small images (under about
+  640x640 pixels at effort 0, 448x448 at 1, 320x320 at 2), browser pages without cross-origin isolation (no
+  SharedArrayBuffer), runtimes without workers, and workers that fail to start encode on the calling thread as before.
+
 ## 3.9.0
 
 ### Features
 
@@ -46,5 +46,11 @@ const prune = dir => {
 };
 prune(path.join(root, 'dist'));
 
+// the worker threads' module: worker.js in the build (written as a literal for bundlers, see threads.ts)
+const threads = path.join(root, 'dist/util/threads.js');
+const threadsCode = fs.readFileSync(threads, 'utf8');
+if (!threadsCode.includes("new URL('./worker.ts', import.meta.url)")) throw new Error('build: the worker URL in threads.js not found');
+fs.writeFileSync(threads, threadsCode.replace("new URL('./worker.ts', import.meta.url)", "new URL('./worker.js', import.meta.url)"));
+
 // the package itself has no "type", so mark the build as ES modules
 fs.writeFileSync(path.join(root, 'dist/package.json'), '{"type":"module"}\n');
@@ -4,7 +4,8 @@
  * container with the boxes libavif writes. The quality maps to the quantizer like avifenc's, with libaom's quantizer_to_qindex (Copyright (c)
  * 2016, Alliance for Open Media, BSD-2-Clause License, see THIRD_PARTY_NOTICES.md)
  */
-import { encodeAV1 } from './av1/encode.ts';
+import { encodeAV1, encodeAV1Threaded, type AV1Image, type AV1Params } from './av1/encode.ts';
+import { startThreads } from '../util/threads.ts';
 
 /** Options of the AVIF encoder */
 export interface AVIFOptions {
@@ -18,8 +19,13 @@ export interface AVIFOptions {
     effort: number;
     /** Exif data (a TIFF header and IFDs) */
     exif?: Uint8Array;
+    /** at most this many worker threads (1: none) */
+    threads: number;
 }
 
+// (images below this many pixels encode faster without threads, which take about 0.1 s to start: by effort)
+const MIN_THREADED_PIXELS = [640 * 640, 448 * 448, 320 * 320];
+
 // libaom's quantizer_to_qindex (avifenc's quality: (100 - quality) * 63 / 100, rounded)
 const QINDEX = [
     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112,
@@ -170,7 +176,7 @@ function seqMonochrome(d: Uint8Array, o: number): boolean {
 }
 
 /** Encodes RGBA pixels as an AVIF (with an alpha image if the image has transparency) */
-export function encode(rgba: Uint8Array, width: number, height: number, { quality, alphaQuality, subsampling, effort, exif }: AVIFOptions): Uint8Array {
+export async function encode(rgba: Uint8Array, width: number, height: number, { quality, alphaQuality, subsampling, effort, exif, threads: maxThreads }: AVIFOptions): Promise<Uint8Array> {
     if (width < 1 || height < 1) throw new RangeError('AVIF: dimensions must be at least 1');
     if (width > 65536 || height > 65536) throw new RangeError('AVIF: dimensions must be at most 65536');
     let opaque = true;
@@ -186,12 +192,35 @@ export function encode(rgba: Uint8Array, width: number, height: number, { qualit
     const cicp = lossless ? [1, 13, 0] : CICP;
     const planes = gray ? [Uint8Array.from({ length: width * height }, (_, i) => rgba[4 * i])]
         : lossless ? [1, 2, 0].map(c => Uint8Array.from({ length: width * height }, (_, i) => rgba[4 * i + c])) : toYUV(rgba, width, height, subsampled);
-    const color = encodeAV1({ planes, width, height, layout: gray ? 0 : subsampled ? 1 : 3, cicp }, { qidx: qindex(quality), effort });
-    let alpha: Uint8Array | null = null;
-    if (!opaque) {
-        const a = new Uint8Array(width * height);
-        for (let i = 0; i < a.length; i++) a[i] = original[4 * i + 3];
-        alpha = encodeAV1({ planes: [a], width, height, layout: 0, cicp: [2, 2, 2] }, { qidx: qindex(alphaQuality), effort });
+    // threads searching superblock rows in a wavefront (each two superblocks behind the one above, so at most half
+    // the superblocks of a row at once) and running filter trials: the same files. Without them (or if they fail, like
+    // workers whose module can't be loaded), the encoder runs here
+    const n = Math.min(maxThreads, height + 63 >> 6, Math.ceil((width + 63 >> 6) / 2));
+    let threads = n > 1 && width * height >= MIN_THREADED_PIXELS[effort] ? startThreads(n) : null;
+    const stop = (): void => {
+        if (threads) for (const t of threads) t.terminate();
+        threads = null;
+    };
+    const av1 = async (image: AV1Image, params: AV1Params): Promise<Uint8Array> => {
+        if (threads) {
+            try {
+                return await encodeAV1Threaded(image, params, threads);
+            } catch {
+                stop();
+            }
+        }
+        return encodeAV1(image, params);
+    };
+    let color: Uint8Array, alpha: Uint8Array | null = null;
+    try {
+        color = await av1({ planes, width, height, layout: gray ? 0 : subsampled ? 1 : 3, cicp }, { qidx: qindex(quality), effort });
+        if (!opaque) {
+            const a = new Uint8Array(width * height);
+            for (let i = 0; i < a.length; i++) a[i] = original[4 * i + 3];
+            alpha = await av1({ planes: [a], width, height, layout: 0, cicp: [2, 2, 2] }, { qidx: qindex(alphaQuality), effort });
+        }
+    } finally {
+        stop();
     }
 
     // the boxes: ftyp, meta (the items, their locations in mdat, their properties), mdat
 
@@ -11,6 +11,7 @@ import * as netpbm from './codecs/netpbm.ts';
 import * as hdr from './codecs/hdr.ts';
 import * as avif from './codecs/avif.ts';
 import * as avifEnc from './codecs/avif-enc.ts';
+import { availableThreads } from './util/threads.ts';
 import * as jxl from './codecs/jxl.ts';
 import type { ToneMapping } from './codecs/hdr.ts';
 import * as quantize from './codecs/quantize.ts';
@@ -234,6 +235,13 @@ export interface AVIFEncodeOptions {
     subsampling?: '4:4:4' | '4:2:0';
     /** How hard the encoder searches for the best modes: 0-2, faster to smaller. Default: `1` */
     effort?: number;
+    /**
+     * At most this many worker threads encode in parallel (the same file, faster: 2.9 times with 8 on a 1920x1080
+     * photo at effort 1), `1` for none. Small images (under about 640x640 pixels at effort 0, 448x448 at 1, 320x320
+     * at 2), and runtimes whose workers can't share memory (browsers without cross-origin isolation), encode without
+     * them. Default: the processors available, at most 8
+     */
+    threads?: number;
     /** Metadata to include, see {@link Metadata} */
     metadata?: Metadata;
 }
@@ -2168,9 +2176,10 @@ export class Image {
      * Encodes the image as AVIF (AV1, with an alpha image if the image has transparency)
      * @param options See {@link AVIFEncodeOptions}
      */
-    async encodeAVIF({ quality = 60, alphaQuality = 100, subsampling = '4:4:4', effort = 1, metadata = {} }: AVIFEncodeOptions = {}): Promise<Uint8Array> {
+    async encodeAVIF({ quality = 60, alphaQuality = 100, subsampling = '4:4:4', effort = 1, threads = Math.max(1, Math.min(availableThreads(), 8)), metadata = {} }: AVIFEncodeOptions = {}): Promise<Uint8Array> {
+        if (!Number.isInteger(threads) || threads < 1) throw new RangeError(`threads must be a positive integer, not ${threads}`);
         const exif = exifData(resolveMetadata(metadata));
-        return avifEnc.encode(this.__bytes__(), this.width, this.height, { quality: finite(quality, 'quality'), alphaQuality: finite(alphaQuality, 'alphaQuality'), subsampling, effort, exif });
+        return avifEnc.encode(this.__bytes__(), this.width, this.height, { quality: finite(quality, 'quality'), alphaQuality: finite(alphaQuality, 'alphaQuality'), subsampling, effort, exif, threads });
     }
 
     /**
 
@@ -0,0 +1,131 @@
+// worker threads: Web Workers (Deno, Bun, browsers) or node:worker_threads (Node), sharing memory through
+// SharedArrayBuffers. Accessed through feature detection with minimal local types, like node:zlib (see zlib.ts)
+
+// (URL and import.meta.url aren't in the es2022 lib)
+declare const URL: new (url: string, base: string) => URL;
+interface URL {
+    readonly href: string;
+}
+declare global {
+    interface ImportMeta {
+        readonly url: string;
+    }
+}
+
+interface NodeWorker {
+    on(event: 'message' | 'error', listener: (value: unknown) => void): void;
+    postMessage(message: unknown): void;
+    terminate(): Promise<number>;
+    unref(): void;
+}
+
+interface WebWorker {
+    onmessage: ((event: { data: unknown }) => void) | null;
+    onerror: ((event: { message?: string, preventDefault?(): void }) => void) | null;
+    postMessage(message: unknown): void;
+    terminate(): void;
+}
+
+declare const Worker: new (url: URL, options: { type: 'module' }) => WebWorker;
+
+interface Globals {
+    process?: { getBuiltinModule?: (id: string) => unknown };
+    Worker?: unknown;
+    navigator?: { hardwareConcurrency?: number };
+    crossOriginIsolated?: boolean;
+}
+
+const globals = globalThis as unknown as Globals;
+
+function builtin<T>(id: string): T | null {
+    try {
+        return (globals.process?.getBuiltinModule?.(id) as T | undefined) ?? null;
+    } catch {
+        return null;
+    }
+}
+
+/** A worker running src/util/worker.ts */
+export interface Thread {
+    /** Runs a task (one at a time), passing the messages it posts on the way to onMessage: its result */
+    run(task: unknown, onMessage?: (message: unknown) => void): Promise<unknown>;
+    terminate(): void;
+}
+
+// what a worker posts: a message on the way, its task's result or the error it failed with
+interface Reply {
+    message?: unknown;
+    result?: unknown;
+    error?: string;
+}
+
+// a thread of a worker posting messages and errors to listeners set once
+function thread(post: (m: unknown) => void, listen: (message: (m: Reply) => void, error: (e: Error) => void) => void, terminate: () => void): Thread {
+    let current: { resolve(v: unknown): void, reject(e: Error): void, onMessage?: (m: unknown) => void } | null = null;
+    listen(m => {
+        if (!current) return;
+        if ('message' in m) current.onMessage?.(m.message);
+        else {
+            const c = current;
+            current = null;
+            if (m.error !== undefined) c.reject(new Error(m.error));
+            else c.resolve(m.result);
+        }
+    }, e => {
+        const c = current;
+        current = null;
+        c?.reject(e);
+    });
+    return {
+        run: (task, onMessage) => new Promise((resolve, reject) => {
+            current = { resolve, reject, onMessage };
+            post(task);
+        }),
+        terminate,
+    };
+}
+
+/** The number of threads the runtime can run in parallel (0 if it can't start workers sharing memory) */
+export function availableThreads(): number {
+    if (typeof SharedArrayBuffer === 'undefined' || typeof Atomics === 'undefined' || globals.crossOriginIsolated === false) return 0;
+    if (!globals.Worker && !builtin('node:worker_threads')) return 0;
+    const os = builtin<{ availableParallelism?(): number, cpus(): unknown[] }>('node:os');
+    const n = os ? os.availableParallelism ? os.availableParallelism() : os.cpus().length : globals.navigator?.hardwareConcurrency ?? 1;
+    return Math.max(1, n | 0);
+}
+
+
+/** Starts n workers, null if the runtime can't */
+export function startThreads(n: number): Thread[] | null {
+    if (n < 1 || !availableThreads()) return null;
+    const threads: Thread[] = [];
+    try {
+        for (let i = 0; i < n; i++) {
+            if (globals.Worker) {
+                // (written like this, bundlers find the worker's module and bundle it too; the build points it at
+                // worker.js)
+                const w = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });
+                threads.push(thread(m => w.postMessage(m), (message, error) => {
+                    w.onmessage = e => message(e.data as Reply);
+                    w.onerror = e => {
+                        e.preventDefault?.();
+                        error(new Error(e.message ?? 'worker failed'));
+                    };
+                }, () => w.terminate()));
+            } else {
+                const { Worker } = builtin('node:worker_threads') as { Worker: new (url: URL) => NodeWorker };
+                const w = new Worker(new URL(import.meta.url.endsWith('.ts') ? './worker.ts' : './worker.js', import.meta.url));
+                // (an idle worker doesn't keep the process alive)
+                w.unref();
+                threads.push(thread(m => w.postMessage(m), (message, error) => {
+                    w.on('message', m => message(m as Reply));
+                    w.on('error', e => error(e as Error));
+                }, () => void w.terminate()));
+            }
+        }
+        return threads;
+    } catch {
+        for (const t of threads) t.terminate();
+        return null;
+    }
+}
@@ -0,0 +1,36 @@
+// the module worker threads run (see threads.ts): tasks posted to it, their results posted back
+import { searchRows, filterTrials, type SearchTask, type FilterTask } from '../codecs/av1/encode.ts';
+
+interface Port {
+    post(message: unknown): void;
+}
+
+interface Globals {
+    process?: { getBuiltinModule?: (id: string) => unknown };
+    postMessage?: (message: unknown) => void;
+    onmessage?: ((event: { data: unknown }) => void) | null;
+}
+
+const globals = globalThis as unknown as Globals;
+
+function handle(port: Port, task: { task: string }): void {
+    try {
+        const message = (m: unknown): void => port.post({ message: m });
+        let result: unknown;
+        if (task.task === 'av1-search') result = searchRows(task as SearchTask, message);
+        else if (task.task === 'av1-filter') result = filterTrials(task as FilterTask);
+        else throw new Error(`unknown task ${task.task}`);
+        port.post({ result });
+    } catch (e) {
+        port.post({ error: String((e as Error).stack ?? e) });
+    }
+}
+
+if (typeof globals.postMessage === 'function' && 'onmessage' in globals) {
+    const port = { post: (m: unknown) => (globals.postMessage as (m: unknown) => void)(m) };
+    globals.onmessage = e => handle(port, e.data as { task: string });
+} else {
+    const { parentPort } = globals.process?.getBuiltinModule?.('node:worker_threads') as { parentPort: { on(e: 'message', l: (m: unknown) => void): void, postMessage(m: unknown): void } };
+    const port = { post: (m: unknown) => parentPort.postMessage(m) };
+    parentPort.on('message', m => handle(port, m as { task: string }));
+}
@@ -69,6 +69,21 @@ const compare = (a, b) => {
         if (Buffer.compare(Buffer.from(exact.bitmap), Buffer.from(screen.bitmap))) panic(`screen content, effort ${effort}: quality 100 isn't lossless`);
     }
 
+    // threads (rows searched in a wavefront, filter trials in parallel): the same files as without, with alpha and
+    // with several tiles too
+    {
+        const big = photo.clone().resize(704, Image.RESIZE_AUTO), alpha = big.clone();
+        for (let i = 3; i < alpha.bitmap.length; i += 4) alpha.bitmap[i] = (i >> 2) % alpha.width;
+        const wide = new Image(4160, 192);
+        for (let y = 0; y < 192; y++) for (let x = 0; x < 4160; x++) wide.setPixelAt(x, y, Image.rgbaToColor(x * 37 & 255, y * 71 & 255, (x ^ y) & 255, 255));
+        for (const [name, image, effort] of [['photo', big, 1], ['alpha', alpha, 0], ['tiles', wide, 0]]) {
+            const one = await image.encodeAVIF({effort, threads: 1, metadata: {creationTime: 0}});
+            const four = await image.encodeAVIF({effort, threads: 4, metadata: {creationTime: 0}});
+            if (Buffer.compare(Buffer.from(one), Buffer.from(four))) panic(`threads, ${name}: not the same file`);
+        }
+        for (const threads of [0, 1.5]) if (!await big.encodeAVIF({threads}).then(() => false, e => e instanceof RangeError)) panic(`threads ${threads} should throw`);
+    }
+
     // odd sizes, a pixel, wider than a tile (4096 pixels)
     for (const [w, h] of [[1, 1], [7, 3], [65, 130], [4100, 8]]) {
         const image = new Image(w, h);