Google's July 9, 2026 launch of LiteRT.js made browser-side AI a lot more practical, but the announcement matters less than the setup discipline around it. If you want local inference without a support queue full of broken demos, use this cheat sheet.
1. Treat the Wasm folder as a deploy artifact
LiteRT.js is not a single import you can forget about after npm install. The runtime expects its Wasm files to be served at runtime, and Google's docs call out the node_modules/@litertjs/core/wasm/ directory explicitly.
That means the first real check is boring: confirm your bundler or static asset pipeline actually ships that folder. If the Wasm path is wrong, everything else in your model pipeline is noise.
import { loadLiteRt, loadAndCompile } from '@litertjs/core';
await loadLiteRt('/litert/wasm/');
const model = await loadAndCompile('/models/resnet18.tflite', {
accelerator: 'webgpu',
});If you are testing from a CDN first, Google documents the JSDelivr path as a clean starting point. For production, hosting the Wasm assets yourself is the safer default.
2. Default to WebGPU, not WebNN hype
The launch post sells three backends: CPU through XNNPACK, GPU through WebGPU, and NPU through WebNN. In practice, the docs make the safer choice obvious.
WebGPU is the normal fast path today. Google's platform requirements say it works across Chrome and Edge 113+, Safari 17.4+, and Firefox 121+ with partial support. WebNN is still experimental in Chromium-based browsers and needs extra browser flags plus JSPI.
So the lazy production rule is simple: ship webgpu first, keep wasm as your fallback, and treat webnn as an opt-in experiment for controlled environments. That is smaller than building a cross-browser feature matrix you do not actually maintain.
3. Keep TensorFlow.js at the edges
LiteRT.js is useful partly because it does not force a full rewrite of an existing browser ML app. Google's docs explicitly recommend TensorFlow.js for pre-processing and post-processing, while LiteRT.js handles model execution.
That split is a good boundary. Let TensorFlow.js keep doing image resize, normalization, and top-k work if your app already uses it. Move only inference to LiteRT.js first.
This is also where the newest package details matter. The current @litertjs/core npm release is 2.5.3, and the docs still show the runtime as a direct fit for existing TensorFlow.js pipelines through @litertjs/tfjs-interop. That makes migration smaller than most browser AI rewrites.
4. Run fake inputs before wiring the UI
Google's get-started guide recommends testing the model with fake inputs before you spend time on pre- and post-processing. That is the right order.
If a model cannot execute on WebGPU, or only works on CPU, you want to find that out before building webcam capture, drag-and-drop upload, or streaming UI around it. LiteRT.js even ships a model tester package for exactly this check.
A useful release gate is:
- Load the model.
- Generate fake inputs from
model.getInputDetails(). - Confirm it runs on
webgpu. - Only then wire the real UI pipeline.
That four-step check catches a surprising amount of wasted frontend work.
5. Plan for fallback and unsupported ops
The announcement emphasizes speedups, but the docs spend more time on failure modes, which is the more useful engineering signal.
The main problems are unsupported operations, unsupported tensor types, shape mismatch bugs on GPU, and models that are too large for the browser memory budget. Google's guidance is blunt: sometimes the right answer is to fall back to wasm, and sometimes you need to rewrite part of the source model and reconvert it.
That means you should not promise "GPU acceleration" as a product invariant. Promise local inference. Then choose the best accelerator the device can actually support.
6. Clean up tensors like you mean it
The npm package docs call out manual memory management, and this is the easiest LiteRT.js footgun to miss. If you create tensors, run the model, move outputs back to Wasm, and never delete them, your nice local demo turns into a tab that bloats over time.
In other words, browser AI still behaves like systems work. Free intermediate tensors, dispose outputs, and keep long-running sessions honest. If your feature depends on a webcam, audio stream, or repeated user prompts, this is not optional housekeeping.
The practical payoff of LiteRT.js is real. Google launched it on July 9 with a clear story: local .tflite execution, WebGPU acceleration, a path to WebNN, and better reuse across the broader LiteRT stack. The teams that benefit fastest will not be the ones chasing every backend on day one. They will be the ones that ship the Wasm assets correctly, benchmark one model, keep a CPU fallback, and clean up memory after every run.