For years, "using AI" meant sending your data to a remote server, waiting for a GPU in a data center to do the math and receiving the answer. Today something has changed quietly but radically: AI can run entirely inside your browser, on your own device, with nothing leaving it. This article explains how it's possible and why it matters more than it seems.
The problem local AI solves
Think about removing a photo's background. The traditional way: you upload the image to a server, a neural network processes it and returns the cutout. It works, but it has three hidden costs:
- Privacy: your image — which could be a document or something personal — travels across the internet and is stored, even for an instant, on someone else's system.
- Cost and infrastructure: someone pays for those GPU servers, which is why almost all these tools end up paid, limited or ad-filled.
- Latency: uploading and downloading takes time, especially with large files.
Local AI removes all three at once. But how does a neural network fit in a browser tab?
The three pieces that make it possible
1. WebAssembly (WASM): near-native code in the browser
JavaScript is flexible but wasn't designed for intensive numerical computation. WebAssembly is a binary format the browser runs at near-native speed. It lets you port libraries written in C++ or Rust — like AI inference engines — and run them on the web with performance unthinkable a decade ago. It's what turns the browser into a serious compute platform.
2. WebGPU: access to the graphics card
Neural networks are, at heart, mountains of matrix multiplications, and GPUs are built for exactly that. WebGPU is the modern API that gives the browser access to the device's GPU for general computation (not just graphics). With WebGPU, an inference that would take a minute on CPU can be solved in seconds. It's the leap that made heavy AI viable in the browser.
When WebGPU isn't available (old browsers, some phones), it falls back to WASM on CPU: slower, but it works everywhere.
3. ONNX and inference runtimes
A trained AI model is saved in a standard format called ONNX (Open Neural Network Exchange). A runtime like ONNX Runtime Web knows how to read that file and execute it using WebGPU or WASM. Libraries like Transformers.js wrap all of this in a simple API, so loading a model and running it is almost as easy as calling a function.
What a "model" really is
An image segmentation model (the one separating subject from background) is a neural network: millions of numbers (the weights) organized in layers. Those weights were adjusted during training, feeding the network thousands of labeled images until it learned to distinguish "subject" from "background" pixel by pixel.
The key point: training is the expensive part and is done once, in large data centers. What runs in your browser is inference: using the already-trained model, which is far lighter. That's why it fits on your device.
The size challenge and quantization
A powerful model can take hundreds of megabytes, too much to download comfortably. This is where quantization comes in: reducing the precision of the model's numbers (for example, from 32 bits to 8 bits) so it weighs much less and uses less memory, in exchange for minimal quality loss. Thanks to this, models that once only ran on servers now fit in a tab.
The trend is clear and favorable: every year brings models that are smaller and more capable. SlimSAM, for example, is a version of Meta's Segment Anything model 100 times smaller than the original, keeping much of the quality.
Why this changes the rules
Local AI isn't just a technical curiosity; it changes what a web tool can be:
- Real privacy: if the computation is local, your data is never uploaded. You can even disconnect the internet after loading the model. For documents, personal photos or confidential material, this is decisive.
- Truly free: with no servers to pay for, a tool can be free with no ads or limits, because the user provides the compute.
- No dependency: it works even if the service "shuts down," because it lives in your browser.
This same technology powers the AI background remover on this site, but the real headline is bigger: the browser has become an AI platform, and that opens the door to OCR, image enhancement, audio transcription and much more, all local and private.
What local AI still can't do
For honesty: not everything fits in the browser. Large language models (GPT-style chatbots) and image generation take gigabytes and demand huge GPUs; that will stay in the cloud for now. Local AI shines in vision tasks (segmenting, detecting, enhancing) and in specialized, compact models. Knowing where the boundary is is part of using it well.
Conclusion
That a neural network runs inside your browser, on your phone or laptop, without sending anything anywhere, would have sounded like science fiction a few years ago. Today it's real thanks to WebAssembly, WebGPU and ever more efficient models. And the best part: the ceiling keeps rising. The next time a website "does magic" with your image without asking you to upload it, you'll know what's happening underneath.
If you want to see it in action, try the local AI background remover: the AI runs entirely in your browser and your image never leaves your device.