TensorFlow.js (often abbreviated TFJS) is an open-source JavaScript library developed by Google for defining, training, and running machine learning models entirely in the web browser, in Node.js, and on mobile through React Native. It was announced on March 30, 2018 at the TensorFlow Developer Summit as the successor to the earlier deeplearn.js library, and it is the JavaScript member of the broader TensorFlow ecosystem, exposing APIs that mirror the Python TensorFlow and Keras interfaces.[1][2] Because computation runs on the user's own device, the official launch post states that "all data stays on the client, making TensorFlow.js useful for low-latency inference, as well as for privacy preserving applications."[1]

Google describes the library as "an open-source library you can use to define, train, and run machine learning models entirely in the browser, using JavaScript and a high-level layers API."[1] It is distributed under the Apache 2.0 license and published as the npm package @tensorflow/tfjs, with separate packages for individual backends, the model converter, the layers API, and platform adapters. The companion academic paper, presented at MLSys 2019, summarises its purpose: "TensorFlow.js is a library for building and executing machine learning algorithms in JavaScript that runs in a web browser and in the Node.js environment."[3]

What is TensorFlow.js used for?

TensorFlow.js is a library for defining tensors, building neural networks, training them with automatic differentiation, and running inference in JavaScript runtimes. Its design goals, set out in the foundational MLSys 2019 paper by Smilkov, Thorat et al., are: full GPU acceleration via the web stack, parity with the Python TensorFlow API where reasonable, the ability to import models trained in Python or other tools, and a compact bundle suitable for shipping over the web.[3] The official documentation frames three core workflows: importing a pre-trained TensorFlow or Keras model for inference, retraining an imported model with transfer learning, and authoring and training new models directly in the browser.[1]

The library targets four main runtimes:

The web browser, where models can run on the user's GPU through WebGL or WebGPU, on the CPU through plain JavaScript, or through compiled WebAssembly (WASM) kernels.
Node.js servers, where bindings to the native TensorFlow C library provide the same speed as Python TensorFlow on CPU and CUDA GPUs.
React Native applications, where an expo-gl adapter exposes the device GPU.
Other JavaScript hosts such as Electron desktops and edge runtimes that ship a browser engine.

In each case the developer writes the same TensorFlow.js code; the library selects the fastest available backend at startup.

When was TensorFlow.js released?

TensorFlow.js was announced on March 30, 2018, but its lineage starts roughly seven months earlier with deeplearn.js. The table below summarises the major milestones.

Date	Milestone
August 11, 2017	deeplearn.js, a WebGL-accelerated JavaScript ML library, announced by Google's PAIR team[5]
March 30, 2018	TensorFlow.js launched at the TensorFlow Developer Summit; deeplearn.js renamed TensorFlow.js Core[1]
2018	Node.js bindings (`@tensorflow/tfjs-node`, `@tensorflow/tfjs-node-gpu`) released
February 2020	React Native adapter (`@tensorflow/tfjs-react-native`) released
March 2020	WebAssembly (WASM) backend introduced
September 2, 2020	WASM backend gains SIMD and multithreading in v2.3.0, up to 10x faster[4]
May 17, 2021	MoveNet pose-detection model and new pose API released[6]
May 2, 2023	Chrome 113 ships WebGPU by default; TFJS WebGPU backend in preview[7]
September 4, 2024	Google rebrands TensorFlow Lite as LiteRT; LiteRT.js web path follows[8]
October 21, 2024	Version 4.22.0 of the umbrella `@tensorflow/tfjs` package released[9]

Deeplearn.js (2017)

The direct predecessor of TensorFlow.js was deeplearn.js, a WebGL-accelerated JavaScript library announced by Google researchers Daniel Smilkov and Nikhil Thorat on August 11, 2017.[5] Smilkov and Thorat were members of Google's PAIR (People + AI Research) initiative, which had previously produced the TensorFlow Playground, an interactive in-browser visualisation of small neural networks. Deeplearn.js generalised the techniques used in the Playground into a full library: tensors stored as WebGL textures, fragment shaders implementing element-wise and matrix operations, and a NumPy-style API with eager execution and automatic differentiation.

Deeplearn.js was aimed at visual demos and education. Early projects shipped in deeplearn.js included style transfer, image-to-image translation, and an in-browser implementation of SqueezeNet. Although the library was popular, it lacked official ties to TensorFlow's Python ecosystem, and its API diverged from the Keras conventions familiar to most ML practitioners.

Launch as TensorFlow.js (2018)

On March 30, 2018, Google relaunched deeplearn.js as TensorFlow.js at the TensorFlow Developer Summit.[1] The relaunch added a Keras-compatible Layers API on top of the existing low-level Core API, plus a converter that imports TensorFlow SavedModel and Keras HDF5 files, and renamed deeplearn.js itself to TensorFlow.js Core. The summit talk by Smilkov and Thorat featured a live demo of training a PAC-MAN controller from a webcam feed, showing that the browser could now do real backpropagation, not just inference.[1]

The launch also introduced the Emoji Scavenger Hunt mobile demo, which used the device camera to detect real-world objects matching emoji prompts. Both demos ran entirely in the browser, with no server-side ML. As the launch post put it, "running machine learning programs entirely client-side in the browser unlocks new opportunities, like interactive ML!"[1]

Continued development (2018 to 2024)

After the launch, TensorFlow.js development tracked the broader TensorFlow release cadence and added several major capabilities:

Node.js bindings (2018): the @tensorflow/tfjs-node and @tensorflow/tfjs-node-gpu packages exposed native TensorFlow C++ kernels to JavaScript on servers, with optional CUDA acceleration on NVIDIA GPUs.
React Native adapter (February 2020): the @tensorflow/tfjs-react-native package brought GPU-accelerated TFJS to mobile apps via Expo's expo-gl and expo-gl-cpp.
WebAssembly backend (March 2020): a WASM backend compiled the XNNPACK kernel library to WebAssembly, giving CPU inference a large speedup over plain JavaScript. With SIMD and multithreading added in version 2.3.0 (September 2020), the WASM backend became up to 10x faster than the plain JS backend.[4]
WebGPU preview (2023): Google Chrome shipped WebGPU by default in Chrome 113 on May 2, 2023, and TensorFlow.js released a preview WebGPU backend that uses compute shaders rather than the older fragment-shader trick used by the WebGL backend.[7]
WebGPU stabilisation (2024): the WebGPU backend matured through 2024 alongside Chromium's WebGPU API, with continued kernel coverage and benchmark improvements.
Version 4.22.0 (October 21, 2024): the most recent release of the main @tensorflow/tfjs umbrella package as of this writing, with TypeScript as the dominant source language for the project.[9]

In parallel, Google's broader on-device ML stack evolved. The team rebranded TensorFlow Lite as LiteRT on September 4, 2024 and introduced LiteRT.js, a Web AI inference path that targets browser deployment of LiteRT (.tflite) models.[8] LiteRT.js can be used alongside TensorFlow.js or as an alternative for browsers that benefit from TFLite's quantisation tooling; Google confirmed that the rename brought "no changes to TensorFlow.js or LiteRT.js web implementations."[8]

Architecture

TensorFlow.js is structured as a small core library plus optional backend modules and higher-level APIs. The pieces fit together in three layers.

Core API

The Core API (@tensorflow/tfjs-core) provides low-level tensor operations, similar to NumPy with automatic differentiation added on top. Tensors are immutable and typed; ops include tf.matMul, tf.conv2d, tf.add, tf.softmax, and several hundred others. Eager execution is the default, meaning each op runs immediately when called. Automatic differentiation is provided through tf.grad and tf.variableGrads, allowing custom training loops and gradient-based optimisation outside the high-level API.

The Core API also exposes memory management primitives. Because WebGL textures live outside the JavaScript garbage collector, developers wrap operations in tf.tidy() to release intermediate tensors automatically, or call dispose() manually on long-lived tensors.

Layers API

The Layers API (@tensorflow/tfjs-layers) is a Keras-compatible high-level API for building, training, and saving neural networks. It supports tf.sequential() for stacked-layer models and tf.model() for arbitrary directed graphs, plus model.compile, model.fit, model.evaluate, and model.predict matching Python Keras conventions. Layers include dense, convolutional, recurrent (LSTM, GRU), normalisation, dropout, and embedding variants. Models written with the Layers API can be saved as a model.json topology file plus binary weight shards, then loaded in any TFJS environment.

Backends

A backend is a TensorFlow.js plugin that implements the actual numeric kernels. The library can be initialised with a specific backend or it will pick the fastest available one. The table below summarises the main backends and where each is used.

Backend	Runtime	Acceleration	Typical use
WebGL	Browser	GPU via WebGL 2.0 fragment shaders	Default browser backend; best for medium and large CNNs
WebGPU	Browser	GPU via WebGPU compute shaders	Newer browsers; targets best-of-class performance
WASM	Browser, Node.js	CPU via compiled XNNPACK kernels with SIMD and threads	Small or quantised models; fallback when GPU is unavailable
CPU (Plain JS)	Browser, Node.js	Pure JavaScript	Universal fallback; slow but always available
Node.js (CPU)	Node.js	Native TensorFlow C++ kernels	Server-side training and inference
Node.js (GPU)	Node.js	Native TensorFlow C++ + CUDA	Server-side training on NVIDIA GPUs
React Native	Mobile	GPU via `expo-gl` (WebGL)	iOS and Android apps

WebGL backend

The WebGL backend is the original GPU path inherited from deeplearn.js. Tensors are stored as WebGL textures and ops are implemented as fragment shaders that read input textures and write output textures. The TensorFlow.js team has reported the WebGL backend running up to roughly 100x faster than the plain JS CPU backend on common CNNs, with most of the time spent in texture fetches rather than floating-point math. Shader programs are compiled lazily on first use and cached, so warm-up cost is paid once per shape.

WebGPU backend

The WebGPU backend uses the newer WebGPU API, which exposes compute shaders and explicit GPU memory management instead of repurposing the graphics pipeline. The package @tensorflow/tfjs-backend-webgpu requires a browser with WebGPU enabled. WebGPU shipped in Chrome 113 on May 2, 2023, and the Chrome team reported "more than three times improvements in machine learning model inferences" relative to WebGL for the same workloads.[7] The TensorFlow.js team has likewise measured WebGPU at around 3x faster inference than WebGL for typical ML workloads, with sub-30 ms response times on small and mid-sized models.

WASM backend

The WASM backend (@tensorflow/tfjs-backend-wasm) compiles Google's XNNPACK kernel library to WebAssembly. As of TensorFlow.js 2.3.0 (September 2, 2020), the WASM backend gained SIMD vector instructions and multithreading support; Google engineers reported that SIMD alone delivers a 1.7x to 4.5x speedup over plain WASM, multithreading adds a further 1.8x to 2.9x, and the two combined make the backend up to 10x faster than plain JavaScript on common models.[4] The benchmark models cited were BlazeFace (about 0.1 million parameters and roughly 20 million multiply-add operations) and MobileNet V2 (about 3.5 million parameters and roughly 300 million multiply-add operations).[4] WASM is on par with or faster than WebGL for small models such as MediaPipe BlazeFace and FaceMesh because it avoids the fixed overhead of compiling shaders. For medium and large CNNs like MobileNet and BodyPix, WebGL is generally 2x to 4x faster than WASM.

CPU backend

The CPU backend is a pure JavaScript implementation, included as a universal fallback when neither WebGL, WebGPU, nor WASM is available. It is slow but works in any JavaScript host.

Node.js backend

The Node.js backends bind directly to TensorFlow's C++ runtime through Node native add-ons. The CPU package is @tensorflow/tfjs-node; the GPU package is @tensorflow/tfjs-node-gpu and requires a CUDA-capable NVIDIA GPU and the matching CUDA toolkit. On Node, performance is comparable to Python TensorFlow because both frontends drive the same C++ kernels.

Capabilities

Can you train models in the browser with TensorFlow.js?

Yes. TensorFlow.js supports full backpropagation in the browser, which is unusual for a JavaScript ML library and was the headline capability of the March 2018 launch. This enables several patterns that would otherwise require a backend server:

Transfer learning on a frozen backbone such as MobileNet, with a small classifier head trained on user-supplied images.
Federated learning, where each client trains locally and only sends gradient updates to a server.
On-device personalisation of recommendation models, gesture detectors, or text predictors using the user's own data without uploading it.

The Layers API exposes the standard model.fit workflow, and the Core API exposes tf.grad and tf.variableGrads for custom training loops.

Inference

Most real applications load a pretrained model and run inference. TensorFlow.js loads models from a model.json file (containing the topology and weight manifest) plus one or more .bin shards (containing the weights). The tf.loadGraphModel function loads converted TensorFlow SavedModels, and tf.loadLayersModel loads converted Keras models or models saved from the TFJS Layers API.

How do you convert a Python TensorFlow or Keras model to TensorFlow.js?

The tfjs-converter is a Python command-line tool, installed via pip install tensorflowjs, that converts existing models to the TensorFlow.js web format. Supported source formats include:

Source format	TFJS loader
TensorFlow SavedModel	`tf.loadGraphModel`
Keras HDF5 (`.h5`)	`tf.loadLayersModel`
TensorFlow Hub modules	`tf.loadGraphModel`
TFLite (`.tflite`), via TensorFlow Lite (LiteRT) tooling and tf2onnx	varies
PyTorch (via ONNX export plus tf2onnx)	varies

The converter writes a directory containing model.json and sharded weight files, with shards typically capped at 4 MB each so they cache well in browsers.

What pre-trained models does TensorFlow.js offer?

Google maintains a separate repository, tensorflow/tfjs-models, of pre-trained models published as npm packages under the @tensorflow-models/* scope. The most commonly used models are listed below.

Model	Task	Notes
MoveNet	Single-person pose estimation	17 keypoints; runs at 50+ fps on modern phones; Lightning and Thunder variants[6]
PoseNet	Multi-person pose estimation	Older single- and multi-pose model; superseded by MoveNet for single-pose use
BodyPix	Person and body-part segmentation	24-part segmentation; used for backgrounds and AR effects
HandPose	Hand landmark detection	21 keypoints per hand; predicts handedness
Face Landmarks Detection	Face mesh and attention	Builds on MediaPipe Face Mesh
Face Detection	Face bounding-box detection	Lightweight detector for camera streams
MobileNet	Image classification	ImageNet labels; small enough to fit in a few megabytes
COCO-SSD	Object detection	Single Shot MultiBox Detector trained on COCO
Universal Sentence Encoder	Text embeddings	512-dimensional sentence embeddings for similarity and classification
Speech Commands	Keyword spotting	Recognises a small set of voice commands from microphone audio
KNN Classifier	Nearest-neighbour classifier	Used as a head for transfer learning on top of MobileNet features
Toxicity	Toxic comment classification	Multi-label classifier for offensive language

MoveNet, released on May 17, 2021, is the flagship pose model: it detects 17 body keypoints, ships in a latency-optimised Lightning variant and an accuracy-optimised Thunder variant, and runs faster than real time (30+ fps, and 50+ fps on many laptops and phones) across modern desktops, laptops, and phones.[6]

In addition, Magenta.js (@magenta/music) is a JavaScript port of Google's Magenta research library for music and art generation. It uses TensorFlow.js for GPU-accelerated inference and ships browser-compatible implementations of MusicVAE (variational autoencoder for melodies, drums, and trios), MusicRNN (LSTM-based MelodyRNN, DrumsRNN, ImprovRNN, PerformanceRNN), and GANSynth (GAN-based audio synthesis). Most Magenta.js models can run inside a Web Worker; GANSynth and Onsets and Frames need direct access to the page's AudioContext to synthesise audio.

Common use cases

TensorFlow.js is used for tasks that benefit from running models close to the user. The most common categories are:

Interactive in-browser ML demos, such as Google's Teachable Machine, which lets non-programmers train an image, audio, or pose classifier from webcam samples and export it for use in TensorFlow.js, TensorFlow Lite, or full TensorFlow.
Client-side image and video processing for video calls and creative tools, including background blur, virtual backgrounds, body-part masks, and AR filters layered on top of camera streams.
Edge inference for privacy, where sensitive data such as health images, personal text, or biometric signals never leaves the device. This is closely related to broader edge AI and edge computing trends in machine learning.
Educational tools like the TensorFlow Playground and Distill articles, which use small TFJS models to illustrate gradient descent, activation functions, and other ML concepts in the browser.
Real-time pose, face, and gesture recognition for AR overlays, fitness apps, and accessibility input. MoveNet is widely used here because it hits 50+ fps on commodity hardware.[6]
Web-based games and creative tools, including procedural music generators and webcam-controlled experiences such as the original PAC-MAN demo.
Hybrid offline-first apps that run inference locally when the network is unavailable and synchronise results once it returns.

Performance characteristics

The practical performance of TensorFlow.js depends heavily on the chosen backend, the model architecture, and the device. Some rough numbers, drawn from the TensorFlow.js team's own benchmarks and blog posts:

WebGL versus CPU: the WebGL backend has been measured at roughly 100x faster than the plain JS CPU backend on typical CNNs. For everyday models such as MobileNet, WebGL is about 5x to 15x faster than the JS backend.
WebGL versus WASM: for medium and large CNNs (MobileNet, BodyPix, PoseNet), WebGL is generally 2x to 4x faster than WASM. For very small models such as MediaPipe BlazeFace and FaceMesh, WASM can match or beat WebGL because it avoids shader-compilation overhead.
WASM versus plain JS: with SIMD and multithreading, the WASM backend is roughly 10x faster than plain JavaScript on common workloads.[4] Benchmarks in the WASM launch post showed MobileNet V2 inference about 3x to 11.5x faster than plain JS in Chrome 79.
WebGPU versus WebGL: the WebGPU backend has been reported to deliver around 3x faster inference than WebGL on machine-learning workloads, with sub-30 ms response times on small and mid-sized models.[7]
Mobile browsers: performance varies widely by device GPU. iOS Safari historically had stricter WebGL limits than desktop Chrome, which sometimes forces fallback to WASM.
Node.js with native bindings: because tfjs-node and tfjs-node-gpu call the same C++ kernels as Python TensorFlow, performance is comparable to native Python TensorFlow on the same hardware.

Memory bandwidth is often the bottleneck for the WebGL backend rather than floating-point throughput, because each op fetches input textures and writes output textures rather than fusing kernels the way a native CUDA implementation would.

How does TensorFlow.js compare with other browser ML libraries?

A number of JavaScript libraries target client-side ML, with different trade-offs in vendor support, model formats, and focus.

Library	Vendor	Year	Backends	Model formats	Focus
TensorFlow.js	Google	2018	WebGL, WebGPU, WASM, CPU, Node native	TFJS, SavedModel via converter, Keras `.h5`	General-purpose ML in browser, Node, and React Native
ONNX Runtime Web	Microsoft	2021	WebGL, WebGPU, WebNN, WASM	ONNX	Cross-framework inference; pairs with PyTorch via ONNX export
Transformers.js	Hugging Face	2023	Built on ONNX Runtime Web (WebGPU, WASM)	ONNX-converted Hugging Face models	NLP and vision pipelines mirroring Python `transformers`
ml5.js	NYU ITP / community	2018	Built on TensorFlow.js	TFJS-compatible models	Friendly API for artists and educators
brain.js	Community	2015	CPU, WebGL via gpu.js	Internal	Simple feed-forward and recurrent networks
ConvNetJS	Andrej Karpathy	2014	CPU only	Internal	Educational; pre-deeplearn.js era
Synaptic	Community	2014	CPU only	Internal	Architecture-free recurrent networks
LiteRT.js	Google	2024	WebGPU, WASM	LiteRT (`.tflite`)	Browser path for the TensorFlow Lite (LiteRT) ecosystem

Transformers.js and ONNX Runtime Web have taken much of the LLM and transformer-inference traffic that might otherwise have gone to TensorFlow.js, in part because most large open-weight models are released first as PyTorch checkpoints and exported to ONNX rather than to the TFJS native format. TensorFlow.js remains the more natural choice for projects that already live in the TensorFlow or Keras ecosystem, for in-browser training, and for the rich tfjs-models pretrained library.

Notable applications

Teachable Machine (teachablemachine.withgoogle.com): Google's no-code in-browser tool for training image, sound, and pose classifiers. The current version supports three input types (images and videos, sounds, body positions). All training happens locally; the tool exports models for use in TensorFlow.js, TensorFlow Lite, or full TensorFlow.
PoseNet and MoveNet demos: Google has released several real-time pose tracking demos using TensorFlow.js, including dance, fitness, and accessibility applications.
Magenta.js music tools: browser-based music sketches such as Latent Loops, Beat Blender, and Tone Transfer use Magenta.js and TFJS to run generative music models without a server.
AR filters and TikTok-style web filters: many web-based filter pipelines run BodyPix or Face Landmarks Detection through TFJS to compose effects on top of camera streams.
In-browser reinforcement learning demos: TensorFlow.js has been used to run small Atari-style RL agents and policy-gradient demos that train in front of the user.
Body language and ergonomics analysis tools: posture-tracking webapps use MoveNet and BodyPix to give feedback during exercise or office work without sending video to a server.

What are the limitations of TensorFlow.js?

TensorFlow.js is constrained by the browser sandbox more than by anything intrinsic to its design.

Memory limits. Browsers cap the amount of memory a tab can use, often around 2 GB on desktop and much less on mobile. WebGL further caps the maximum texture size, which limits the largest activations a model can hold.
Single JavaScript thread. Without Web Workers or the WASM backend's threadpool, all computation runs on the page's main thread, which makes the UI sluggish during heavy training.
GPU access is constrained. WebGL and WebGPU expose less of the underlying GPU than native CUDA does. Features such as fused kernels, persistent kernel launches, and tensor cores are not directly accessible.
First-load model size. Models in the 10 MB to 50 MB range are practical for fast first-load over the network, with weight shards cached by the browser. Multi-hundred-megabyte models load slowly on first visit.
LLM-scale models. TensorFlow.js is not the typical choice for in-browser large language models. Most browser LLM demos use Transformers.js on top of ONNX Runtime Web, with quantised weights and WebGPU compute shaders.
Cross-browser quirks. WebGL behaviour varies between Chrome, Firefox, and Safari; WebGPU support is still uneven across mobile browsers, especially on iOS.
Native TensorFlow gaps. The kernel coverage of the WebGL and WebGPU backends lags behind TensorFlow's native C++ kernels, so some operations from imported SavedModels fall back to the CPU.

Recent developments (2023 to 2026)

WebGPU backend maturation. Chrome 113 shipped WebGPU by default in May 2023, and the TensorFlow.js WebGPU backend has progressed from preview to a serious production option through 2024 and 2025, with kernel coverage and performance closing in on WebGL across common CNN and transformer workloads.[7]
Transformer support. TensorFlow.js has improved support for transformer architectures, but Hugging Face's Transformers.js has emerged as a popular alternative for browser LLM and transformer inference, often built on ONNX Runtime Web instead of TFJS.
LiteRT.js. Google rebranded TensorFlow Lite as LiteRT on September 4, 2024 and introduced LiteRT.js, a Web AI inference path for .tflite models that complements TensorFlow.js for browser deployment.[8]
Continued community work. The tensorflow/tfjs repository has been steadily maintained, with version 4.22.0 released in October 2024 and ongoing kernel and converter improvements.[9]

Integration

TensorFlow.js is framework-agnostic and works with React, Vue, Angular, Svelte, and vanilla JavaScript. Two installation paths are common:

NPM: npm install @tensorflow/tfjs adds the umbrella package, which includes the Core API, Layers API, default browser backends (WebGL, CPU), and the Data and Vis utilities. Specific backends can be installed separately, for example @tensorflow/tfjs-backend-webgpu or @tensorflow/tfjs-backend-wasm.
CDN: loading <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script> from a CDN gives a window.tf global without a build step, which is convenient for prototyping.

The library is written in TypeScript and ships its own type definitions, so editors can autocomplete tensor shapes and op names. Tree-shaking is supported when importing only the kernels and ops a project uses.

License and governance

TensorFlow.js is released under the Apache 2.0 license, the same license as the rest of the TensorFlow ecosystem. The project is governed by Google with significant external contributions; the source lives at github.com/tensorflow/tfjs. Pre-trained models live in the parallel tensorflow/tfjs-models repository, also under Apache 2.0.

References

TensorFlow Blog. "Introducing TensorFlow.js: Machine Learning in JavaScript." March 30, 2018. https://blog.tensorflow.org/2018/03/introducing-tensorflowjs-machine-learning-javascript.html
TensorFlow.js Official Site. https://www.tensorflow.org/js
Smilkov, Daniel, Nikhil Thorat, et al. "TensorFlow.js: Machine Learning for the Web and Beyond." Proceedings of MLSys 2019, pp. 309-321. arXiv:1901.05350. https://arxiv.org/abs/1901.05350
Yuan, Ann, and Marat Dukhan. "Supercharging the TensorFlow.js WebAssembly backend with SIMD and multi-threading." TensorFlow Blog, September 2, 2020. https://blog.tensorflow.org/2020/09/supercharging-tensorflowjs-webassembly.html
Google Research Blog. "Harness the Power of Machine Learning in Your Browser with deeplearn.js." August 11, 2017. https://research.google/blog/harness-the-power-of-machine-learning-in-your-browser-with-deeplearnjs/
TensorFlow Blog. "Next-Generation Pose Detection with MoveNet and TensorFlow.js." May 17, 2021. https://blog.tensorflow.org/2021/05/next-generation-pose-detection-with-movenet-and-tensorflowjs.html
Beaufort, Francois. "Chrome ships WebGPU." Chrome for Developers Blog, May 2, 2023. https://developer.chrome.com/blog/webgpu-release
Google Developers Blog. "TensorFlow Lite is now LiteRT." September 4, 2024. https://developers.googleblog.com/en/tensorflow-lite-is-now-litert/
TensorFlow.js Releases. "tfjs v4.22.0." GitHub, October 21, 2024. https://github.com/tensorflow/tfjs/releases
TensorFlow.js GitHub Repository. https://github.com/tensorflow/tfjs
TensorFlow.js Models GitHub Repository. https://github.com/tensorflow/tfjs-models
TensorFlow.js Guide: Platform and Environment. https://www.tensorflow.org/js/guide/platform_environment
TensorFlow.js Guide: Models and Layers. https://www.tensorflow.org/js/guide/models_and_layers
TensorFlow.js Guide: Node.js. https://www.tensorflow.org/js/guide/nodejs
TensorFlow.js Guide: Model Conversion. https://www.tensorflow.org/js/guide/conversion
TensorFlow Blog. "Introducing the WebAssembly backend for TensorFlow.js." March 2020. https://blog.tensorflow.org/2020/03/introducing-webassembly-backend-for-tensorflow-js.html
TensorFlow Blog. "TensorFlow.js for React Native is here!" February 2020. https://blog.tensorflow.org/2020/02/tensorflowjs-for-react-native-is-here.html
Magenta.js Documentation. https://magenta.github.io/magenta-js/music/
Magenta.js GitHub Repository. https://github.com/magenta/magenta-js
Teachable Machine. https://teachablemachine.withgoogle.com/
Hugging Face Transformers.js Documentation. https://huggingface.co/docs/transformers.js/index
ONNX Runtime Web Documentation. https://onnxruntime.ai/docs/tutorials/web/
W3C Workshop on Web and Machine Learning: "Fast client-side ML with TensorFlow.js." 2020. https://www.w3.org/2020/06/machine-learning-workshop/talks/fast_client_side_ml_with_tensorflow_js.html

Editing: TensorFlow.js