Background removal used to require expensive software, manual clipping paths, and hours of work. Then came AI-powered online tools — fast, but with a catch: your images get uploaded to someone else's server. Pixly changes that equation entirely.
The Problem with Server-Side Processing
When you upload an image to a typical background removal service, that image leaves your device, travels across the internet, and lands on a server you don't control. You have no idea how long it's stored, who can access it, or whether it's being used to train AI models.
- Your images may be stored indefinitely on remote servers
- Server-side processing requires bandwidth and time for uploads
- You depend on the service's uptime and availability
- Sensitive or confidential images are exposed to third parties
How Pixly Does It Differently
Pixly runs entirely in your browser using WebGPU and TensorFlow.js. The ML model — a fine-tuned version of U²-Net — is downloaded once and cached locally. After that, every background removal happens on your device, with zero network requests.
// Pixly client-side pipeline
const model = await pixly.loadModel("u2net");
const result = await model.removeBackground(image, {
threshold: 0.5,
edgeRefine: true,
outputFormat: "png",
});Performance You Can Measure
Thanks to WebGPU acceleration, Pixly processes a 12-megapixel image in about 2.3 seconds on a modern laptop. That's comparable to server-side tools — but without the upload time. On devices without WebGPU, we fall back to WebGL, which still delivers sub-5-second processing.
We wanted to prove that privacy doesn't have to come at the cost of performance. With WebGPU, we're actually faster than most cloud-based tools.
The U²-Net Architecture Explained
U²-Net is a two-stage architecture designed specifically for salient object detection. The first stage, called the detection module, identifies the most visually significant objects in the image. The second stage, the refinement module, takes this coarse prediction and produces a pixel-precise segmentation mask. This two-pass approach is what allows Pixly to handle complex scenarios like hair, fur, and translucent objects that trip up simpler models.
What makes U²-Net particularly well-suited for browser deployment is its efficient architecture. The model uses a U-Net backbone with residual blocks, which means it can produce high-quality results with a relatively small parameter count. The compressed version we use is about 44MB — small enough to download in seconds and cache for offline use.
Under the Hood
Pixly's U²-Net model is quantized to 8-bit integers, reducing its size by 4x with negligible quality loss. This quantization, combined with WebGPU compute shaders, allows the model to run inference on a 12MP image in just 2.3 seconds on a modern laptop.
Edge Cases and How We Handle Them
Background removal is not a solved problem. Some images are straightforward — a product on a white background, for example. Others are genuinely hard: a person with curly hair against a busy background, a glass object on a patterned surface, or a subject that blends into the background. Pixly uses several techniques to handle these edge cases.
- Edge refinement: After initial segmentation, we apply a morphological edge-detection pass to clean up jagged boundaries
- Alpha matting: For hair and fur, we estimate per-pixel transparency values rather than binary masks
- Color decontamination: We remove background color bleeding from edge pixels to prevent halos
- Adaptive thresholding: The segmentation threshold adjusts based on image contrast and complexity
For best results with hair or fur, use an image where the subject is well-lit and the background has a different tone. High contrast between subject and background dramatically improves segmentation accuracy.
Privacy by Architecture
The privacy benefits of client-side processing cannot be overstated. When you use a cloud-based background remover, your image is transmitted to a server, processed, and then sent back. During that window, the server has a copy of your image. It may be cached in memory, written to a log, stored in a backup, or used for model training. You have no way to verify what happens to it.
With Pixly, there is no server. The model runs in your browser tab. When you close the tab, the processed image and the original are gone from memory. There are no logs, no caches, no backups. Your images exist only on your device and in your downloads folder. This is not a privacy policy — it is a technical guarantee.
Not all tools that claim to be "private" actually process images locally. Some use the word "private" to mean they do not share your data with third parties, but they still upload your images to their own servers. Always check the Network tab in DevTools to verify.
Getting Started
To try it yourself, just head to the Background Remover tool, drop in an image, and watch the magic happen. No signup, no upload, no waiting. Your images stay yours — literally.
Once you've removed the background, you can download the result as a transparent PNG, place it on a new background using the Background Editor, or batch process multiple images at once. The entire workflow is free, unlimited, and happens entirely in your browser.
Key Takeaways
- Pixly uses U²-Net for background removal, running entirely in your browser via WebGPU
- Processing takes ~2.3 seconds for a 12MP image — faster than most cloud-based alternatives
- Your images never leave your device — privacy is guaranteed by architecture, not policy
- Edge refinement and alpha matting handle difficult cases like hair and fur
- The model is downloaded once (44MB) and cached for instant future use