WebGPU Is Making Websites Act Like Desktop Apps. Mostly.
Open a tab, edit a complex design, process images, or run an AI model without sending every calculation to a server. WebGPU is making more of that possible. But the idea that desktop software is about to disappear comes with some important conditions.
The interesting question isn’t whether a browser can run demanding software anymore. It’s what happens when the software needs more memory, faster hardware, or a feature your browser doesn’t support.
WebGPU isn’t the first time websites have used your GPU.
Your browser has been using the graphics processor for years. WebGL made hardware-accelerated graphics possible on the web, including 3D scenes, interactive visualisations, and complex design canvases.
WebGPU builds on that history. It offers a modern interface for graphics work and adds compute shaders, which let web applications run suitable calculations across large amounts of data in parallel.
CPU
Handles browser logic, application decisions, event handling, and many tasks that need flexible, sequential processing.
GPU + WebGPU
Runs suitable graphics and compute workloads across many data elements simultaneously, when the task benefits from it.
The key distinction: WebGPU does not make every task faster simply by existing. Developers must build a workload that benefits from GPU processing, and the device must support the required features.
It also doesn’t replace the server side of the web. Websites still rely on servers for things such as accounts, shared data, payments, and many application services. Our explanation of why PHP still powers so much of the web covers the other side of that relationship.
Technical reference: Chrome’s WebGPU overview ↗
Figma didn’t wait for WebGPU to replace a desktop app.
Figma Design launched in 2015 with a rendering system built around WebGL. It showed that a complex design canvas could work inside a browser long before WebGPU arrived.
In September 2025, Figma described its updated renderer powered by WebGPU. The change opened up new performance optimisation opportunities for an application that was already running on the web.
WebGL
The browser could already display and manipulate complex design canvases using GPU-accelerated graphics.
WebGPU
A newer interface gives developers more control over GPU work, creating opportunities to reduce overhead and improve performance in demanding rendering tasks.
WebGPU can improve what a browser application is capable of. It doesn’t mean WebGPU invented browser-based software, or that every installed application can now move into a tab without compromises.
Read the original: Figma’s engineering explanation of its WebGPU renderer ↗
Your browser can now do some of the AI work itself.
The same GPU computing capabilities that help with graphics can also accelerate machine-learning calculations. That is why WebGPU has become important to projects that run AI models directly inside the browser.
For example, WebLLM can run compatible language models locally. Hugging Face’s Transformers.js can run tasks such as text classification, image recognition, speech recognition, and other machine-learning workloads without requiring every inference to be handled by a remote server.
Your input
Text, an image, or audio supplied to a compatible application.
Local inference
The downloaded model performs supported calculations on your device through the browser’s computing stack.
Your result
A classification, transcription, summary, or generated response, depending on the model.
Once the model is available, local inference can reduce network delays and can work without a connection for suitable offline applications.
An application designed for genuine local-only processing can keep the inference itself on your device.
Available memory, processing speed, model size, and browser support all influence whether the experience is practical.
These capabilities do not mean a browser can run every large hosted AI model at the same quality or speed. Some applications offer CPU-based fallbacks, while others require WebGPU. The implementation matters.
The AI runs locally. The download doesn’t disappear.
Before a browser can run a model, it needs the model files. For language models, those files can be large enough to make the first visit feel more like installing software than opening a website.
Qwen2.5-1.5B
A compact language-model option listed in WebLLM’s guide.
Phi-3.5 Mini
A larger model download with greater hardware demands.
Llama 3.1 8B
A much heavier download aimed at more capable hardware.
Illustrative model-download sizes from WebLLM’s documentation. Actual file sizes depend on the model, quantisation and build. These figures are download sizes, not the amount of GPU memory the application will necessarily need at runtime.
The first visit can be the slowest one.
A compatible application may download the model and cache it in browser storage. Returning to the same site can be faster because it may reuse that cached model.
The cache has limits.
Browser storage is managed by site origin. A separate AI website cannot automatically reuse another site’s origin-specific model cache, and stored data can be removed when site data is cleared.
Hardware still decides what feels usable.
A model that loads on one laptop may run slowly, consume too much memory, or fail to fit comfortably on another device. Mobile hardware adds battery and heat constraints.
Removing the cloud from inference can reduce network dependence, but it moves more of the storage and computing burden onto the user’s device.
Model-size and caching references: WebLLM documentation ↗
Local processing can help privacy. It doesn’t guarantee it.
One advantage of browser-based AI is the possibility of processing a prompt, document, or image on the device instead of uploading it to a remote inference service. But that benefit only exists when the application is designed to keep that information local.
Input stays on the device
The inference can happen without sending the prompt to a remote model server. The model itself may still need to be downloaded first.
Some information leaves the device
The server may process the request and return the result. The application’s data handling depends on its architecture and privacy practices.
What the phrase “runs locally” doesn’t tell you
An application can run inference locally while still transmitting analytics, account information, usage events, or other data. It may also send some requests to a cloud service through a fallback mode.
WebGPU supplies a computing capability, not a privacy policy. Before using a browser-based AI tool for confidential work, check whether it offers an explicit local-only mode and what information it sends to external services.
Further reading: WebLLM’s local inference and storage documentation ↗
“Supported in all major browsers” doesn’t mean supported everywhere.
Browser support is no longer simply a question of whether a browser vendor has implemented WebGPU. The operating system, GPU hardware, graphics drivers, and browser version all matter.
Chrome and Edge
BROAD, WITH CAVEATSWebGPU is available on supported desktop configurations including Windows and macOS, with ChromeOS and compatible Android devices also supported. Linux support depends on the browser version and graphics hardware; recent Chromium releases have expanded support to particular Intel GPUs.
Firefox
PLATFORM-DEPENDENTStable support is available on Windows and Apple Silicon Macs in supported Firefox versions. Firefox 147 also broadened Apple Silicon support to earlier macOS releases. Linux and Android remain gaps in the stable implementation status documented for this article.
Safari
VERSION 26Safari 26 introduced WebGPU support across Apple’s macOS, iOS, iPadOS, and visionOS 26 platforms. Older operating-system and browser combinations should not be assumed to have the same capabilities.
Some applications can use an alternative implementation when WebGPU is unavailable. Others require it and cannot run without it. A site may load successfully while a particular feature remains unusable on the same device.
Check current availability: WebGPU implementation status ↗ · Safari 26 release details ↗
Compatibility reviewed on October 24, 2026. Browser and operating-system updates may change the status.
The browser is getting more powerful. The compromises are still there.
WebGPU makes an important category of software more practical to build for the browser. It gives developers better tools for graphics and compute-heavy work, including local AI inference. That can make browser applications feel closer to desktop software.
Where it makes sense
Interactive 3D, complex visualisations, creative tools, image processing, and compatible AI models that benefit from local GPU acceleration.
Where the promise weakens
Large downloads, limited memory, unsupported hardware, platform differences, and workloads that aren’t well suited to GPU processing.
What desktop software still offers
Deeper operating-system integration, specialised workflows, established plug-in ecosystems, and more predictable access to local files and hardware-specific capabilities.
WebGPU is not going to eliminate desktop applications overnight. It is removing some of the technical reasons developers had to avoid putting demanding software in a browser in the first place.
The next question is whether those browser applications can deliver a dependable experience across ordinary devices, without asking users to tolerate huge downloads or hardware limitations that remain invisible until something fails.
The future may look like an app opening in a tab. The experience still depends on the hardware underneath it.
Related reading
WebGPU is part of a broader shift in how browsers, AI tools, and web applications work. These guides explore some of the connected questions.
PHP Still Runs 70% of the Web. Then a Critical Bug Hit
What happens behind the browser, and why the server-side technology powering websites still matters.
Read the article ↗ BROWSER COMPATIBILITYJPEG XL Is Back: 3 Reasons AVIF Still Wins for Now
A practical look at why technical capabilities and real-world browser support don’t always line up.
Read the article ↗ AI AND COMPUTEAI Productivity Loop: The Hidden Waste of AI Text
An examination of the costs and trade-offs behind using AI for everyday work.
Read the article ↗Sources and technical documentation
The central technical claims in this article are based on browser-vendor documentation, project engineering reports, and the published documentation for local AI libraries.
- Chrome for Developers — Overview of WebGPU
- Figma — Rendering: Powered by WebGPU
- Hugging Face — Running models on WebGPU
- WebLLM — Model downloads, caching, privacy, and requirements
- GPUWeb — WebGPU implementation status by browser and platform
- WebKit — WebGPU in Safari 26
- Mozilla Graphics — WebGPU in Firefox
- Babylon.js — WebGPU snapshot rendering and its limitations
Browser support and model-download figures reflect the cited documentation available when this article was prepared. Model sizes, feature support, and hardware requirements vary by implementation and may change with later releases.
